{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "3dbe160f",
   "metadata": {},
   "source": [
    "# KWS20 Audio Evaluation and Inference Test\n",
    "With this notebook, you can evaluate a KWS quantized checkpoint using .wav audio files or .npy sample data.\n",
    "You need the trained model and the quantized checkpoint. A recorded 16khz mono .wav file can be used as the input.\n",
    "It can also mix a clean audio file with background noise at different SNR levels and evaluate the inference result.\n",
    "\n",
    "To play the audio files, you need to install sounddevice:\n",
    "\n",
    "$pip3 install sounddevice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "277c32ba",
   "metadata": {},
   "outputs": [],
   "source": [
    "###################################################################################################\n",
    "#\n",
    "# Copyright (C) 2022-2023 Maxim Integrated Products, Inc. All Rights Reserved.\n",
    "#\n",
    "# Maxim Integrated Products, Inc. Default Copyright Notice:\n",
    "# https://www.maximintegrated.com/en/aboutus/legal/copyrights.html\n",
    "#\n",
    "###################################################################################################\n",
    "\n",
    "import os\n",
    "import sys\n",
    "\n",
    "import numpy as np\n",
    "import torch\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import scipy.io.wavfile as wav\n",
    "\n",
    "import importlib\n",
    "import librosa\n",
    "import soundfile as sf\n",
    "import sounddevice as sd  # If you need to install: $pip3 install sounddevice\n",
    "\n",
    "from IPython.display import clear_output\n",
    "\n",
    "sys.path.append(os.path.join(os.getcwd(), '..'))\n",
    "sys.path.append(os.path.join(os.getcwd(), '../models/'))\n",
    "\n",
    "import ai8x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a240549e",
   "metadata": {},
   "source": [
    " Specify the quantized checkpoint and model to import.\n",
    " \n",
    " Enter your own model file name to import (e.g. 'ai85net-kws21-v3.py'):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "90276895",
   "metadata": {},
   "outputs": [],
   "source": [
    "trained_checkpoint_path = os.path.join(\"..\", \"..\", \"ai8x-synthesis\", \"trained\", \"ai85-kws20_v3-qat8-q.pth.tar\")\n",
    "mod = importlib.import_module(\"ai85net-kws20-v3\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ad61981",
   "metadata": {},
   "source": [
    "Define the ordered list of classes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e61be7b9",
   "metadata": {},
   "outputs": [],
   "source": [
    "classes = ['up', 'down', 'left', 'right', 'stop', 'go', 'yes', 'no', 'on', 'off', 'one',\n",
    "           'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'zero', 'unknown']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c86e8f07",
   "metadata": {},
   "source": [
    "Now, let's define some functions to help with the evaluation:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08afbbae",
   "metadata": {},
   "source": [
    "# A) Functions to mix audio with noise at different SNRs\n",
    "Use add_noise with a signal and a noise .wav file to generate a series of mixed audio files with different SNRs. \n",
    "\n",
    "The snr_mixer2() combines the clean audio with the noise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "04175b88",
   "metadata": {},
   "outputs": [],
   "source": [
    "def snr_mixer2(clean, noise, snr):\n",
    "    \"\"\"\n",
    "    Mix clean and noise with provided SNR level.\n",
    "    \"\"\"\n",
    "    eps = 1e-8\n",
    "    s_pwr = np.var(clean)\n",
    "    noise = noise - np.mean(noise)\n",
    "    n_var = s_pwr / (10**(snr / 10))\n",
    "    noise = np.sqrt(n_var) * noise / (np.std(noise) + eps)\n",
    "    noisyspeech = clean + noise\n",
    "\n",
    "    if max(abs(noisyspeech)) > 1:\n",
    "        noisyspeech /= max(abs(noisyspeech))\n",
    "    return noisyspeech"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "cdee3f9c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_noise(signal_file, noise_file, out_folder='Mixed_SNR', snr_low=-5, snr_high=20):\n",
    "    \"\"\"\n",
    "    Mix an audio file with background noise for the provided range of SNR levels and copy them to out_folder.\n",
    "    \"\"\"\n",
    "    sample_rate = 16384\n",
    "    \n",
    "    noise, noise_samplerate = librosa.load(os.path.join('', noise_file),\n",
    "                                           sr=sample_rate)\n",
    "    signal, signal_samplerate = librosa.load(os.path.join('', signal_file),\n",
    "                                             sr=sample_rate)\n",
    "\n",
    "    # make the noise size the same as signal\n",
    "    noise_concat = noise\n",
    "    while len(signal) > len(noise_concat):\n",
    "        noise_concat = np.concatenate((noise_concat, noise), axis=0)\n",
    "\n",
    "    noise_concat = noise_concat[:len(signal)]\n",
    "\n",
    "    try:\n",
    "        os.makedirs(out_folder)\n",
    "    except:\n",
    "        pass\n",
    "\n",
    "    for db in range(snr_low, snr_high, 1):\n",
    "        noisy = snr_mixer2(signal, noise_concat, db)\n",
    "        # sd.play(noisy, 16384)\n",
    "        print(f'mixing {signal_file} and {noise_file} at {db}db          ', end='\\r')\n",
    "        sf.write(os.path.join(out_folder, os.path.basename(signal_file)[:-4] + \"_SNR_\" + str(db) + \"db.wav\"),\n",
    "                 noisy, sample_rate)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa5ff1f7",
   "metadata": {},
   "source": [
    "# B) Functions to quantize, evaluate and run accuracy tests\n",
    "These helper functions are used to quantize, evaluate and run the accuracy test for a series of mixed audio & noise files:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "6c9e36c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def quantize_audio(data, num_bits=8, compand=False, mu=10):\n",
    "    \"\"\"\n",
    "    Quantize audio\n",
    "    \"\"\"\n",
    "    step_size = 2.0 / 2**num_bits\n",
    "    max_val = 2**num_bits - 1\n",
    "    q_data = np.round((data - (-1.0)) / step_size)\n",
    "    q_data = np.clip(q_data, 0, max_val)\n",
    "    return np.uint8(q_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "1f452cd5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def softmax_2(x):\n",
    "    \"\"\"\n",
    "    Softmax implementation similar to izer: y_i = 2^(x_i/16384) / sum(2^(x_j/16384))\n",
    "    \"\"\"\n",
    "    bx = np.power(2, x/16384)\n",
    "    sm = bx.sum(axis=0)\n",
    "    return bx / sm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "e4338f21",
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate(fname, index=0, scale=1, play=True, plot=True):\n",
    "    \"\"\"\n",
    "    Evaluate a 16khz sampled .wav file, or a sample_data.npy.\n",
    "    fname: .wav or .npy file\n",
    "    index: Specify a sample index to start inference from\n",
    "    scale: If needed, scale samples by the specified value \n",
    "    play: True to play the audio\n",
    "    plot: True to plot\n",
    "    \"\"\"\n",
    "    if fname[len(fname)-3:] == \"npy\":\n",
    "        samples = torch.tensor(np.load(fname), dtype=torch.float)\n",
    "\n",
    "        # In case it is a npy file that is 1-d, make it 2-d 128x128\n",
    "        if samples.shape[0] == 128*128:  # convert to 128x128\n",
    "            samples_128 = np.zeros((128, 128)).astype(\"float32\")\n",
    "            for k in range(128):\n",
    "                for j in range(128):\n",
    "                    samples_128[j, k] = samples[k*128 + j]\n",
    "            samples = torch.from_numpy(samples_128)\n",
    "    else:\n",
    "        (rate, sig) = wav.read(os.path.join(fname))\n",
    "        sig = scale*sig[index:index+16384]\n",
    "        # print(f'Rate: {rate}, Len: {len(sig)}')\n",
    "        if play:\n",
    "            sd.play(sig, rate)\n",
    "        sig = np.pad(sig, [0, 16384-sig.size])\n",
    "        \n",
    "        sig_q = quantize_audio(sig/(2*max(sig)))  # double the magnitude\n",
    "\n",
    "        samples = np.zeros((128, 128)).astype(\"float32\")\n",
    "        for k in range(128):\n",
    "            for j in range(128):\n",
    "                samples[j, k] = sig_q[k*128 + j]\n",
    "        samples = torch.from_numpy(samples) - 128.0\n",
    "      \n",
    "    # print(f' Shape: {samples.shape}, Min: {samples.min()}, Max: {samples.max()}')   \n",
    "    sample_in = torch.unsqueeze(samples, 0)\n",
    "    \n",
    "    # evaluate\n",
    "    model.eval()\n",
    "    out = model(sample_in)\n",
    "    # print(out)\n",
    "\n",
    "    # find the detected class\n",
    "    out_vals = np.argmax(out[0, :].detach().cpu().numpy(), axis=0)\n",
    "\n",
    "    # softmax for confidence\n",
    "    conf = softmax_2(out[0, :].detach().numpy())\n",
    "    conf = int(100*conf[out_vals])\n",
    "    \n",
    "    if plot:\n",
    "        plt.title(classes[out_vals].upper() + \"(\" + str(conf) + \"%)\")\n",
    "        plt.plot(np.transpose(samples).flatten())\n",
    "        plt.show()\n",
    "    \n",
    "    # print(f'Class: {out_vals} ({classes[out_vals].upper()})')\n",
    "    # print(f'Confidence: {conf}%')\n",
    "    \n",
    "    return out_vals, conf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "f3e93298",
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_accuracy_audio(index_list, expected_output_list, audio_file_name):\n",
    "    \"\"\"\n",
    "    Evaluate a 16khz samples .wav file, or a sample_data.npy.\n",
    "    index_list: the list of sample index for each uttered word in the audio_file\n",
    "    expected_output_list: the list of expected classes for uttered words in the audio_file\n",
    "    \"\"\"\n",
    "    right = 0\n",
    "    right_conf = 0.0\n",
    "    for k in range(0, len(index_list)):  \n",
    "        cl,co = evaluate(audio_file_name, index_list[k], scale=1, play=False, plot=False)\n",
    "        #  print(cl,co)\n",
    "        if expected_output_list[k] == cl:\n",
    "            right += 1\n",
    "            right_conf += co\n",
    "        k += 1\n",
    "        # clear_output(wait=True)\n",
    "    if right != 0:\n",
    "        right_conf = right_conf/right\n",
    "    # print(f'SNR: {snr}, Total correct: {right}/{i}, avg_conf: {right_conf}')\n",
    "    return right/k, right_conf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "0562a3c1",
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_accuracy_test(index_list, class_list, input_folder, snr_low=-5, snr_high=25):\n",
    "    \"\"\"\n",
    "    Run accuracy test by evaluating all 16khz mixed signal and noise files generated by\n",
    "    add_noise function. Each file name ends with \"_snrvalue\" followed by \"db.wav\".\n",
    "    index_list: the list of sample index for each uttered word in the audio_file\n",
    "    class_list: the elist of xpected classes for uttered words in the audio_file\n",
    "    input_folder: folder with all audio files\n",
    "    \"\"\"\n",
    "    snr = np.zeros(snr_high - snr_low)\n",
    "    accuracy = np.zeros(snr_high - snr_low)\n",
    "    conf = np.zeros(snr_high - snr_low)\n",
    "    n = 0 \n",
    "    for n, k in enumerate(range(snr_low, snr_high)):\n",
    "        snr[n] = k \n",
    "        for (dirpath, dirnames, filenames) in os.walk(os.path.join(\"\", input_folder)):\n",
    "            for filename in sorted(filenames):\n",
    "                # print(filename)\n",
    "                if filename.endswith(\"_\" + str(k) + \"db.wav\"):\n",
    "                    # print(dirpath)\n",
    "                    accuracy[n], conf[n] = find_accuracy_audio(index_list, class_list, os.path.join(dirpath, filename))\n",
    "                    print(f'{filename}: Accuracy: {accuracy[n]*100}%, Avg Conf: {conf[n]}')\n",
    "    return snr[0:n], accuracy[0:n]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "6068cbbe",
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_far_frr_audio(index_list, expected_output_list, audio_file_name, threshold=50):\n",
    "    \"\"\"\n",
    "    Finds False Acceptance Rate and False Rejection Rate on an audio file with multiple utterances.\n",
    "    index_list: the list of sample index for each uttered word in the audio file\n",
    "    expected_output_list: the list of expected classes for uttered words in the audio file\n",
    "    audio_file: .wav audio file\n",
    "    threshold: acceptance threshold(0-100)\n",
    "    \"\"\"\n",
    "    true_accept = 0\n",
    "    true_reject = 0\n",
    "    false_accept = 0\n",
    "    false_reject = 0\n",
    "    for i in range(0, len(index_list)):  \n",
    "        cl, co = evaluate(audio_file_name, index_list[i], scale=1, play=False, plot=False)\n",
    "        # print(cl,co)\n",
    "        \n",
    "        if co >= threshold:   # Accept\n",
    "            if expected_output_list[i] == cl:  # True\n",
    "                true_accept += 1\n",
    "            else: # False\n",
    "                false_accept += 1\n",
    "                \n",
    "        else: # Reject\n",
    "            if expected_output_list[i] == cl:  # False\n",
    "                false_reject += 1\n",
    "            else:\n",
    "                true_reject += 1\n",
    "\n",
    "        i += 1\n",
    "    return true_accept/len(index_list), true_reject/len(index_list), \\\n",
    "        false_accept/len(index_list), false_reject/len(index_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "26461257",
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_far_frr_test(index_list, class_list, input_folder, snr_low=-5, snr_high=25, \n",
    "                     threshold_low=50, threshold_high=100, threshold_step=1):\n",
    "    \"\"\"\n",
    "    Run FAR and FRR test on all files in a folder.\n",
    "    index_list: the list of sample index for each uttered word in the audio files. It should be the same for all audio files.\n",
    "    class_list: the list of expected classes for uttered words in the audio files It should be the same for all audio files.\n",
    "    input_folder: the folder with all snr mixed files\n",
    "    snr_low, snr_high: the range of snr to choose from all snr mixed files\n",
    "    threshold_low, threshold_high, threshold_step: the range and step to scan the acceptance threshold\n",
    "    \"\"\"\n",
    "\n",
    "    thr = np.zeros(1 + (threshold_high - threshold_low)//threshold_step)\n",
    "    far = np.zeros(1 + (threshold_high - threshold_low)//threshold_step)\n",
    "    frr = np.zeros(1 + (threshold_high - threshold_low)//threshold_step)\n",
    "    tar = np.zeros(1 + (threshold_high - threshold_low)//threshold_step)\n",
    "    trr = np.zeros(1 + (threshold_high - threshold_low)//threshold_step)\n",
    "  \n",
    "    cnt = 0\n",
    "    n = 0\n",
    "    for k in range(snr_low, snr_high):\n",
    "        for (dirpath, dirnames, filenames) in os.walk(os.path.join(\"\", input_folder)):\n",
    "            for filename in sorted(filenames):              \n",
    "                if filename.endswith(\"_\" + str(k) + \"db.wav\"):\n",
    "                    for n, t in enumerate(range(threshold_low, threshold_high, threshold_step)):\n",
    "                        print(f'{dirpath} {filename} Threshold = {t}          ', end='\\r')\n",
    "                        tar_val, trr_val, far_val, frr_val = find_far_frr_audio(index_list, class_list, \n",
    "                                                                os.path.join(dirpath, filename), t)\n",
    "                        cnt += 1\n",
    "                        thr[n] = t\n",
    "                        far[n] += far_val\n",
    "                        frr[n] += frr_val\n",
    "\n",
    "                        tar[n] += tar_val\n",
    "                        trr[n] += trr_val\n",
    "                        # clear_output(wait=True)\n",
    "    return thr[0:n+1], far[0:n+1]/cnt, frr[0:n+1]/cnt, tar[0:n+1]/cnt, trr[0:n+1]/cnt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2da217c8",
   "metadata": {},
   "source": [
    "# Step 1: Generate mixed audio and noise\n",
    "In this step, we mix an audio file with multiple utterances with a background noise file with the defined SNR range. They both should be .wav and will be converted to 16KHz mono .wav.\n",
    "\n",
    "This step is only needed once. It generates noisy audio files for each SNR level and stores in the output folder. \n",
    "These files will be used to evaluate the accuracy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "d754f0f7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mixing kws_audio/voice_AN_All.wav and kws_audio/tradeshowmedium.wav at 24db           \r"
     ]
    }
   ],
   "source": [
    "# Signal file is a clean audio with keyword utterance, Noise file is a background audio\n",
    "add_noise(signal_file=os.path.join('kws_audio', 'voice_AN_All.wav'), \n",
    "          noise_file=os.path.join('kws_audio', 'tradeshowmedium.wav'), \n",
    "          out_folder=os.path.join('kws_audio', 'Mixed_AN_All_TradeShow'),\n",
    "          snr_low=-15, snr_high=25)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "343b4bd7",
   "metadata": {},
   "source": [
    "# Step 2: Initialize and load the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "145e1b35",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Working with device: cuda\n",
      "Configuring device: MAX78000, simulate=True.\n"
     ]
    }
   ],
   "source": [
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "print(\"Working with device:\", device)\n",
    "\n",
    "ai8x.set_device(device=85, simulate=True, round_avg=False)\n",
    "qat_policy = {'start_epoch': 10, 'weight_bits': 8, 'bias_bits': 8}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f6ebace",
   "metadata": {},
   "source": [
    "Make sure the name of the model in the python model file is correct here (e.g. AI85KWS20Netv3):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "cbdcdfcf",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = mod.AI85KWS20Netv3(num_classes=len(classes), num_channels=128, dimensions=(128, 1), bias=False, \n",
    "                           quantize_activation=True, weight_bits=8, bias_bits=8)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8e3cfa1",
   "metadata": {},
   "source": [
    "Load the quantized checkpoint:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "463177a7",
   "metadata": {},
   "outputs": [],
   "source": [
    "checkpoint = torch.load(trained_checkpoint_path)\n",
    "model.load_state_dict(checkpoint['state_dict'], strict=False)\n",
    "ai8x.update_model(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aedeebd6",
   "metadata": {},
   "source": [
    "# Step 3: Evaluate a sample data or .wav audio\n",
    "Now you can run the inference on a .npy sample data (128x128 or 16384x1 samples), or a mono 16KHz .wav audio file. \n",
    "For audio files, you can specify the sample index to start the inference from (16K samples representing 1-sec audio). You can turn off the plot and audio playback."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "e5d17691",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "(13, 62)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Evaluate the izer generated sample data\n",
    "evaluate(os.path.join('..', '..', 'ai8x-synthesis', 'tests', 'sample_kws_20.npy'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "0f2eba83",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Class: down(1), Confidence: 99%\n"
     ]
    }
   ],
   "source": [
    "# Evaluate an example audio file\n",
    "audio_file = os.path.join('kws_audio', 'Mixed_AN_All_TradeShow', 'voice_AN_All_SNR_0db.wav')\n",
    "class_det, confidence = evaluate(audio_file, index=30000, scale=1, plot=True, play=False)\n",
    "print(f' Class: {classes[class_det]}({class_det}), Confidence: {confidence}%')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "303428e3",
   "metadata": {},
   "source": [
    "# Step 4: Run accuracy test for mixed audio files with different SNR values\n",
    "In this step, it runs the accuracy test to evaluate all mixed audio files generated in step 1.\n",
    "\n",
    "Audio files are expected to be originated from the same clean audio, mixed with different levels of background noise.\n",
    "\n",
    "We need to know the sample index for each keyword utterance audio files, which should be the same for all.\n",
    "The sample index of the beginning of each keyword and the expected keyword class for that utterance should be provided (it can be determined by listening to the clean audio at different indexes in the previous step)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "8122521b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Index is the sample index for each utterance in the audio files (should be the same for all audio files in our test)\n",
    "index_AN_ALL = [12000, 28000, 44000, 60000, 72000, 88000, 104000, 120000, 136000, 150000, 162000, 178000, 192000,\n",
    "                210000, 226000, 242000, 258000, 272000, 286000, 300000]\n",
    "# Expected class number for each utterance. In this example, the order is up, down, ... as defined in classes.\n",
    "class_AN_ALL = range(0, 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "866fa547",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiEAAAGJCAYAAABcsOOZAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAADQ70lEQVR4nOydd5gT1frHvymb3WUbva+LiAiL0tuiVCmWKyqCXVDhd1UEFbxKEUH03ouVi15WUBC4NAGliAuCFCkCClKkI51le01PZpK8vz+yCdkmM5lsZg+ez/PwMGTz5pzv9z0Zzs6ZOa+GiAgcDofD4XA4YUardgc4HA6Hw+H8NeGTEA6Hw+FwOKrAJyEcDofD4XBUgU9COBwOh8PhqAKfhHA4HA6Hw1EFPgnhcDgcDoejCnwSwuFwOBwORxX4JITD4XA4HI4q8EkIh8PhcDgcVeCTEI5i3nnnHWg0GuTn56vdFVVZtGgRNBoNLl265H+tT58+6NOnj2p9CkSj0eCdd94Je7vNmjXDs88+G/Z2w8WOHTug0WiwY8cO/2vPPvssmjVrplqf5BKOsdGnTx/cfvvtVdoGhz34JITDqea8/vrrSE5OBnBtoqPRaPDzzz+Xey8RITExERqNBn/729/C3dWQ43a70bhxY2g0Gvzwww8Vvsc3CW7QoAFsNlu5nzdr1kyRF48++ig0Gg0mTJgQ9Gf8Gb5JjJQ/1ZG8vDy8+uqraNWqFaKjo1G/fn107doVEyZMgMViUbt7nGqOXu0OcDg3Mj/++KPiz9iwYQMeeOCBUq9FRUVh+fLluOuuu0q9vnPnTly9ehWRkZHlPsdut0OvZ+srv337dmRlZaFZs2ZYtmwZ7r333krfm5ubizlz5uD1118PWfsmkwnff/89mjVrhq+//hrvv/9+yCcDrVu3xpIlS0q9NmnSJMTGxuKtt94KaVuhprCwEJ07d4bJZMLzzz+PVq1aoaCgAEePHsWcOXPw0ksvITY2Vu1ucqoxbJ2ROBzGMBgMiuIvXLiAM2fOYO7cuaVev++++/DNN9/gs88+KzWxWL58OTp16lTh0lhUVJSivqjB0qVL0bFjR4wYMQKTJ0+G1WpFTExMhe9t3749PvroI4wePRrR0dEhaX/16tVwu91YsGAB+vXrh127dqF3794h+WwfDRo0wNNPP13qtffffx9169Yt93ogHo8HgiComtevvvoKV65cwZ49e9CjR49SPzOZTIrHP+fGhy/HcKqEy5cvo0WLFrj99tsxffp06HQ6FBcX+3/+ySefQKPRYPz48f7X3G434uLiSl32XrFiBTp16oS4uDjEx8fjjjvuwKeffiqrLwsXLkS/fv1Qv359REZGIjk5GXPmzCn3vsrWxSu6p+HEiRPo168foqOj0bRpU/zzn/+Ex+MpF1vRPSG5ubkYOXIkGjRogKioKLRr1w7/+9//Kuz7hg0bkJCQUO6KxxNPPIGCggJs2bLF/5ogCPj222/x5JNPVvhZgfrsdjtatWqFVq1awW63+99TWFiIRo0aoUePHnC73QC8/9nNmjULbdq0QVRUFBo0aIAXXngBRUVFpT6fiPDPf/4TTZs2RY0aNdC3b1+cOHGiwr5IwW63Y+3atXj88cfx6KOPwm6347vvvqv0/VOnTkVOTk6FuQ2WZcuWYcCAAejbty9at26NZcuWheyz5aLRaDBmzBgsW7YMbdq0QWRkJDZt2gQA+Pjjj9GjRw/UqVMH0dHR6NSpE7799ttyn+F0OjFu3DjUq1cPcXFxGDx4MK5evVphexkZGXj++efRoEEDREZGok2bNliwYEGp95w/fx46nQ7du3cvFx8fH1/hBOnkyZPo27cvatSogSZNmuDDDz8s9x4p35GOHTtiyJAhpV674447oNFocPToUf9rK1euhEajwalTpyrUyVEXPgnhhJzz58+jV69eiIuLw44dOzB48GB4PJ5S9zDs3r0bWq0Wu3fv9r92+PBhWCwW9OrVCwCwZcsWPPHEE6hVqxY++OADvP/+++jTpw/27Nkjqz9z5sxBUlISJk+ejE8++QSJiYkYPXo0UlNTg9KXnZ2Nvn374siRI5g4cSJee+01LF68WNLkyG63o0+fPliyZAmeeuopfPTRR0hISMCzzz5bYfzGjRsxYMCAcssozZo1Q0pKCr7++mv/az/88AOMRiMef/zx6/YjOjoa//vf/3Du3LlSl/xffvllGI1GLFq0CDqdDgDwwgsv4I033sCdd96JTz/9FM899xyWLVuGQYMGQRRFf+zUqVPx9ttvo127dvjoo4/QvHlzDBw4EFar9br9qYj169fDYrHg8ccfR8OGDdGnT58/nQT07NkT/fr1w4cfflhqYhUsmZmZ+Omnn/DEE08A8E78vv32WwiCoPizg2X79u0YN24cHnvsMXz66af+m18//fRTdOjQAe+++y7+/e9/Q6/XY9iwYdiwYUOp+FGjRmHWrFkYOHAg3n//fUREROD+++8v105OTg66d++OrVu3YsyYMfj000/RokULjBw5ErNmzfK/LykpCW63u9xyUmUUFRXhnnvuQbt27fDJJ5+gVatWmDBhQqn7faR+R3r27FnqnFJYWIgTJ06UO6/s3r0b9erVQ+vWrSX1kRNmiMNRyLRp0wgA5eXl0alTp6hx48bUpUsXKiwsJCIit9tN8fHx9OabbxIRkcfjoTp16tCwYcNIp9OR2WwmIqKZM2eSVquloqIiIiJ69dVXKT4+nlwul6L+2Wy2cq8NGjSImjdvXuo1ADRt2rRy701KSqIRI0b4//3aa68RAPr111/9r+Xm5lJCQgIBoIsXL/pf7927N/Xu3dv/71mzZhEAWrp0qf81QRAoJSWFYmNjyWQy+V+3Wq0UFRVFCxcu9L+2cOFCAkAHDhyg2bNnU1xcnF/fsGHDqG/fvv4+33///dfVN2nSJNJqtbRr1y765ptvCADNmjXL//Pdu3cTAFq2bFmpuE2bNpV6PTc3lwwGA91///3k8Xj875s8eTIBKOWfVP72t7/RnXfe6f/3l19+SXq9nnJzc0u9L3D87dy5kwDQzJkz/T+vyAspfPzxxxQdHe3PyR9//EEAaO3ataXe99NPPxEA+umnn/yvjRgxgpKSkmS36aNNmzalxg2RN39arZZOnDhR7v1lx7ggCHT77bdTv379/K8dOXKEANDo0aNLvffJJ58sNzZGjhxJjRo1ovz8/FLvffzxxykhIcHfXnZ2NtWrV48AUKtWrejFF1+k5cuXU3Fxcbk+9u7dmwDQ4sWL/a85nU5q2LAhPfLII/7XpH5HfOP15MmTRES0fv16ioyMpMGDB9Njjz3mj23bti09/PDD5frDqR7wKyGckHH8+HH07t0bzZo1w9atW1GrVi0AgFarRY8ePbBr1y4AwKlTp1BQUICJEyeCiLBv3z4A3t9Ybr/9dtSsWRMAULNmTVit1lJLDsEQeH+A0WhEfn4+evfujQsXLsBoNMr+vI0bN6J79+7o2rWr/7V69erhqaeekhTbsGFD/2/XABAREYFXXnkFFosFO3fu9L++fft2OJ3OSm/G9C1RpKWlwWw2Iy0trdKlmMp455130KZNG4wYMQKjR49G79698corr/h//s033yAhIQEDBgxAfn6+/0+nTp0QGxuLn376CQCwdetWCIKAsWPHlrpx87XXXpPVHx8FBQXYvHlzKZ8eeeQRaDQarFq1qtK4Xr16oW/fviG5GrJs2TLcf//9iIuLAwDceuut6NSpk6pLMr179/Y/KRVI4BgvKiqC0WhEz549cejQIf/rGzduBIBS+QXK54iIsHr1ajzwwAMgolJ5HzRoEIxGo/9zGzRogN9//x0vvvgiioqKMHfuXDz55JOoX78+3nvvPRBRqc+OjY0tdZ+LwWBA165dceHChVL9lPId6dmzJwD4zyu7d+9Gly5dMGDAAP+VkOLiYhw/ftz/Xk71g09COCHjgQceQFxcHDZv3oz4+PhSP+vZsycOHjwIu92O3bt3o1GjRujYsSPatWvnP2H8/PPPpU4Wo0ePRsuWLXHvvfeiadOmeP755/1r4HLYs2cP+vfvj5iYGNSsWRP16tXD5MmTASCoScjly5dx6623lnv9tttukxyr1Zb+6vkuFV++fNn/2oYNG9C5c2c0aNCgws+qV68e+vfvj+XLl2PNmjVwu90YOnSoHCkwGAxYsGABLl68CLPZjIULF5aaRJw9exZGoxH169dHvXr1Sv2xWCzIzc0t1e+yvtSrV88/GZXDypUrIYoiOnTogHPnzuHcuXMoLCxEt27drjsJeOedd5CdnV3uZl45nDp1CocPH8add97pb//cuXPo06cP0tLSYDKZgv5sJdx8880Vvp6Wlobu3bsjKioKtWvXRr169TBnzpxS4/vy5cvQarW45ZZbSsWWHbd5eXkoLi7Gl19+WS7nzz33HAD48w4AjRo1wpw5c5CVlYUzZ87gs88+Q7169TB16lR89dVXpT67adOm5Z4uqlWrVqn7i6R+Rxo0aIBbb73Vf/7YvXs3evbsiV69eiEzMxMXLlzAnj174PF4+CSkGsOfjuGEjEceeQT/+9//sGzZMrzwwgulfnbXXXdBFEXs27fPf7IAvJOT3bt34/Tp08jLyyt1sqhfvz6OHDmCzZs344cffsAPP/yAhQsXYvjw4ZXeyFmW8+fP4+6770arVq0wc+ZMJCYmwmAwYOPGjfjPf/5T4c2kZfHdoBluNm7c6D/pV8aTTz6J//u//0N2djbuvfde/1UkOWzevBkA4HA4cPbs2VL/0Xk8HtSvX7/S//jr1asnuz0p+Nq78847K/z5hQsX0Lx58wp/1qtXL/Tp0wcffvghXnzxxaDaX7p0KQBg3LhxGDduXLmfr169+rq5qQoqeupn9+7dGDx4MHr16oXPP/8cjRo1QkREBBYuXIjly5fLbsP3nXj66acxYsSICt/Ttm3bcq9pNBq0bNkSLVu2xP33349bb70Vy5Ytw6hRo/zv8d1nVJayV0ykctddd2Hbtm2w2+04ePAgpk6d6r+aunv3bpw6dQqxsbHo0KFDUJ/PqXr4JIQTMj766CPo9XqMHj0acXFxpZYGunbtCoPBgN27d2P37t144403AHj/w5g3bx62bdvm/3cgBoMBDzzwAB544AF4PB6MHj0aX3zxBd5++220aNHiun36/vvv4XQ6sX79etx0003+133LCIHUqlWr1BM8gPeJk6ysrFKvJSUl4ezZs+Xiz5w5c93+JCUl4ejRo/B4PKV+0zt9+rT/54B3aevKlSsV3jQYyMMPP4wXXngBv/zyC1auXHnd9sty9OhRvPvuu3juuedw5MgRjBo1CseOHUNCQgIA4JZbbsHWrVtx5513/uljr75+nz17ttTkIC8vr9xTNNfj4sWL2Lt3L8aMGVPucViPx4NnnnkGy5cvx5QpUyr9jHfeeQd9+vTBF198IattwPsf4vLly9G3b1+MHj263M/fe+89LFu2TJVJSEWsXr0aUVFR2Lx5c6n9YRYuXFjqfUlJSfB4PDh//nypqx9lx63vyRm3243+/fsH1afmzZujVq1a5b47UpD6HQG8v8QsXLgQK1asgNvtRo8ePaDVanHXXXf5JyE9evSodPLDUR++HMMJGRqNBl9++SWGDh2KESNGYP369f6fRUVFoUuXLvj6669x5cqVUldC7HY7PvvsM9xyyy1o1KiRP6agoKDU52u1Wv9vYE6nU1KffCefwN+0jEZjuRM04P0P17e+7OPLL78sdyXkvvvuwy+//IL9+/f7X8vLy5N0r8B9992H7OzsUhMGl8uF//73v4iNjfX/p7tx40Y0aNAAnTt3/tPPi42NxZw5c/DOO++U29DseoiiiGeffRaNGzfGp59+ikWLFiEnJ6fUb/6PPvoo3G433nvvvXLxLpfLP2nr378/IiIi8N///reU14FPUkjF5+Obb76JoUOHlvrz6KOPonfv3tf1unfv3ujTpw8++OADOBwOWe3v2bMHly5dwnPPPVeu/aFDh+Kxxx7DTz/9hMzMTNnaqgKdTgeNRlNqnF66dAnr1q0r9T7fvUWfffZZqdfL5kin0+GRRx7B6tWrcfz48XLt5eXl+Y9//fXXCp9+2r9/PwoKCiQtUZZF6ncEuHZfyAcffIC2bdv6J889e/bEtm3b8Ntvv/GlmGoOvxLCCSlarRZLly7FQw89hEcffRQbN25Ev379AHhPDO+//z4SEhJwxx13APAuudx22204c+ZMub04Ro0ahcLCQvTr1w9NmzbF5cuX8d///hft27eX/LjdwIED/VdTXnjhBVgsFsybNw/169cv91vaqFGj8OKLL+KRRx7BgAED8Pvvv2Pz5s2oW7duqfe9+eabWLJkCe655x68+uqriImJwZdffun/De7P+Pvf/44vvvgCzz77LA4ePIhmzZrh22+/xZ49ezBr1iz/TZAbNmzAvffeK2l3zsoumV+Pf/7znzhy5Ai2bduGuLg4tG3bFlOnTsWUKVMwdOhQ3HfffejduzdeeOEFzJgxA0eOHMHAgQMRERGBs2fP4ptvvsGnn36KoUOHol69evjHP/6BGTNm4G9/+xvuu+8+HD58GD/88EM5/67HsmXL0L59eyQmJlb488GDB2Ps2LE4dOgQOnbsWOnnTJs2DX379pXVtq99nU5X6VWowYMH46233sKKFStK7XOjFvfffz9mzpyJe+65B08++SRyc3ORmpqKFi1alBqP7du3xxNPPIHPP/8cRqMRPXr0wLZt23Du3Llyn/n+++/jp59+Qrdu3fB///d/SE5ORmFhIQ4dOoStW7eisLAQALBkyRIsW7YMDz/8MDp16gSDwYBTp05hwYIFiIqK8t97JQep3xEAaNGiBRo2bIgzZ85g7Nix/td79erl32+IT0KqOeo9mMO5UQh8RNKHzWaj3r17U2xsLP3yyy9ERLRhwwYCQPfee2+p+FGjRhEA+uqrr0q9/u2339LAgQOpfv36ZDAY6KabbqIXXniBsrKyZPVv/fr11LZtW4qKiqJmzZrRBx98QAsWLCj3OK3b7aYJEyZQ3bp1qUaNGjRo0CA6d+5cuUd0iYiOHj1KvXv3pqioKGrSpAm999579NVXX133EV0iopycHHruueeobt26ZDAY6I477ij1GG5xcTHp9XpatWpVOS2Bj+j+Gdd7RPfgwYOk1+tp7Nixpd7jcrmoS5cu1LhxY/+j0kTex2M7depE0dHRFBcXR3fccQe9+eablJmZWcq/6dOnU6NGjSg6Opr69OlDx48fr9C/yjh48CABoLfffrvS91y6dIkA0Lhx44io4vHnw/dYqNRHdAVBoDp16lDPnj3/9H0333wzdejQgYjC+4juyy+/XOH7v/rqK7r11lspMjKSWrVqRQsXLvT7EojdbqdXXnmF6tSpQzExMfTAAw9Qenp6hY9v5+Tk0Msvv0yJiYkUERFBDRs2pLvvvpu+/PJL/3uOHj1Kb7zxBnXs2JFq165Ner2eGjVqRMOGDaNDhw6V+rzevXtTmzZtyvW9Iq+u9x0JZNiwYQSAVq5c6X9NEASqUaMGGQwGstvtFcZxqgcaoiDvCOJwOFXCqlWr8NRTTyE/P99/eZnD4XBuRPg9IRxONaNmzZr47LPP+ASEw+Hc8PArIRxmyc7O/tOfR0dH8//Iqxlq56ywsPBPt13X6XQhf+xYjTY5HFbgkxAOs1zvps0RI0Zg0aJF4ekMRxJq56xPnz6ldqUtS1JSEi5dusR8mxwOK/CnYzjMcr3t3Bs3bhymnnCkonbOPvnkkz/dt+TP9kJhqU0OhxX4lRAOh8PhcDiqwG9M5XA4HA6Howp/ueUYj8eDzMxMxMXFSdoIisPhcDgcjhcigtlsRuPGjcsVGQyGv8wkJDU1FampqRAEAefPn1e7OxwOh8PhMEt6ejqaNm2q+HP+cveEGI1G1KxZE8cPHULiLbfAVVJXQh8VBZfdDmi10EdGQrTZoNHpvMdWK7QREdAZDLDm5mL9/ffjkZICaPqoKGj1eghmM/TR0dDq9XCaTIiIiYFWp4PTZIIhNhbQaGDNzsb3gwdjSEmxtsj4eHjcbohWq/fY5YLLbochLs577HDAEBsLtyjCIwggIqzu2xeDN2xATP36cDmdILcbETVqwOV0Ah4P9NHRFWryiCJW9+mDh378EdG1a5fSJFqt0BoM0EVEQLBYKtRUmJGBB5OT8UN6OiIAvybBbIYhLg4ggmCxVKjJlp+PtMGD8dCPP0Kr15fSFBETA7cgwCOKiIiJqVCTx+3G6j598ODmzahRp46kPPk0uZ1OrO7TBw9v3YqomjUl5SlQkzUnB2kPPoiHtmyBRqORlCefJlNhIR647TZsOH8eNWrUkJSnQE0V5uw6efJpctntWN27N4b89BMMcXGS8hSoyV5QgO8feAAPbt4MvcEgKU8+TYLVivX33ovBGzfCEBcnKU+Bmmw2G/6WmIj1Fy8ivnZtSXnyaXIYjVjbrx8e2bnT7+v18hSoyWky4fv778eDmzYhIjpaUp58mlxOJ7675x48kJaGqFq1JOUpUJNgtWJNnz4YsmMHDDExkvLk02QqLMTgm29GWno6oqOiJOUpUJNot3v7vmEDIuPjJeXJp8njdmPdwIH423ffoUb9+pLyFKjJUVyMtXfffS1nEvLk02QvLMS6gQPxyI4d0Or1ss7lotUKu9OJ+26+Gd+fPo2EevUkn8sFsxnQaLCmXz88sH49Yhs1knUuj4iJKd33iAjJ53J9ZCSseXlYf++9eGTHDmg0GlnncqfJBCLCugED8LfvvkNMgwaSz+Uuux0FJhNaJSejuLg4NI/Tq7JPq4oYjUYCQBnp6UHFu0WRLm3aRG5RDGus2m2bjUZqD5DZaAx726x6rsQzpW2z7Dkfa3yshattPtbkx2eUbPNvDHKsleUvdyXEZDIhISEBGenpaByCS0l/FSwmE3omJGC30YjY+Hi1u8ME3LPg4L7Jh3sWHNw3+WRevYomiYkwGo2ID4Fn/OkYmQhmM75q2tR7OS6MsWq3rQSWdbPqG8ueK4Fl3az6xrLnSmBZt5q+lSMk11MYIhTLMZl79wZ9CS3YWLXbVnrZklXdSuJDcYmcRd18rPGxxkrbfKzx5Ziww5djgoNftpQP9yw4uG/y4Z4FB/dNPnw5RmWcJhPmxMfDaTKFNVbttpXAsm5WfWPZcyWwrJtV31j2XAks61bTt3KE5HoKQyhejnG5KP/4cXK7XGGNVbttRZctGdatJF7xJXJGdfOxxscaK23zsSY/ni/HKIQvxwQHv2wpH+5ZcHDf5MM9Cw7um3z4cozKOE0mfKrRBH0JLdhYtdtWAsu6WfWNZc+VwLJuVn1j2XMlsKxbTd/KEZLrKQyhdDnG43aTKT2dPG53WGPVblvJZUuWdSuJV3qJnFXdfKzxscZK23ysyY8P9XIMvxIiF40Ghvh4IJjid0pi1W5bCSzrZtU3lj1XAsu6WfWNZc+VwLJuNX0rw192EuLbk9/lcFw7ttu9+/YDEG22a8dWK9yCAACwZmdjbkICBLMZgsUCj8sFwLv5i+/YaTLB43b7j8njARHBkpGBuQkJcBqN/stgHrf72rHL5d88xuNyQbBYAABuUYRotUIwmzE3IQHW7Gxvf51OiDab/9hlt1eqyRdrz88vp0m0WuEWRa+OSjQJJhN8wzVQk68OAXk8lWqyZGZibkICHEVF5TQBgFsQ/McVafL13ZaXJzlPPk2+WEdRkeQ8BWry5cxRXCw5T2U1uWXkKVCTP2cFBZLz5NPki3UajZLzFKjJmpXlbbuwUHKefJpseXnefOXmSs5TWU36kn5IzZNPh6O42P/9lJsnl9MJa06O/3siNU8+HfaCAv/3U2qeAjU5TSZvzgL+fb08+TR5RNFfjVRqngI12fPzvX3PyZGVJ8FshqOoCHMTEmDJyJCcp0BNvnh/zmScI3z9Fsxm2edy0WqFp0STKPNc7jSZ/PmyZGRIzlOgJt94EcxmWedyAP5xKpjNss/lTpPJ/z2xZGTIOpdXxeZmf5lJSGpqKpKTk9GlSxcAwIEpUwAAeydPxt7JkwEAO8aOxW8zZgAAfhwxAkdTUwEAaUOG4NTixQCADUOGYMCiRTDExWFlt25ILylGt6R1a+QcOAAAWNC0KYpOnwYAb6IzMyGYzViQmIjn09P9/0EAQNHp01hQcoNszoEDWNK6NQAgfds2rOzWDQBwYd06rOnfH4a4OPT+7DNsefZZAMDR1FT8OGIEAOC3GTOwY+zYSjUZ4uLQ/MEH/ToCNa3p3x8X1q0DgEo1rUhOhq9UUaAm3xfBN9GoSNPKbt3wotGInP37y2kCgFOLFyNtyJBKNRni4tD25Zf9uZGSJ58mQ1wcarVqhZz9+yXnKVDTgsREvGg0wpqRITlPPk3bnn4aAHBy3jzJeQrUZIiLQ9N+/XB+7VrJefJpMsTFAfCefKTmKVDT2gED8KLRiKvbtknOk0/TbzNm4EWj0X8sJU9lNT0MIO/QIcl58mmyZmQgIi4Ohrg4yXkK1LRz7Fi8aDTi99mzJefJp+n82rV40WjEhiFDJOcpUFMgUvPk03Q5LQ0DS2Kl5ilQ0++zZ+NFoxE7x46VlaclrVuj6PRpvGg0YklysuQ8BWoqOn0aMY0bwxAXJzlPPk2/z56NVs88A0NcnOxz+Zr+/XE5LQ0AsP7uu2Wdy306nj55EgsSEyXnKVDT+bVr0bRfPxji4mSdywFg59ixSPnXv2CIi5N9Ll/QtCmsGRl40WjEgsREWedyn6aQEpJFHYbw3RNy+exZIiIS7XYS7Xbvsc1GosNBRESC1Xrt2GIhl9NJREROk4mKL1wgj9tNTrPZv+Oc02TyHzuMRv+jTw6jkTxuN3k8HrIXFZHxyhVyiyI5StbT3C7XtWNRJKfJdO3YbCYiIpcgkGCxkMftpqLz5/3vER0OEqxW/7Fos1WqyeN2U+Eff5BQ8p5ATYLFQi5B8OqoRFNBejp1KFk7DdTkMBrJ4/GQx+2uVJOjuJhM6enkcjrLaSIicjmd/uOKNHncbio8e/ba6xLy5NPkcbup4PTpUvm7Xp4CNdmLirx9FwTJefJpKszMpPYAFefmSs5ToCaP200FZ8743yMlTz5NHreb8k+eJLcoSs5ToCaH0Uim9HRvPiTmyadJsFrJlJ5OgsUiOU+BmsxGI3UGyFhQIDlPPh0uQaD8kyfJ43ZLzlOgJqfZ7O27zSY5Tz4dot1OpvR0cppMkvMUqMntcnlzVpI/OecIY34+dS75fkrNU6AmwWbz9t1slpwnnyaX00mm9HSyFxVJzlOgJpfTSQWnTl3LmYxzhGCzUeEff5DH7ZZ9LhcsFjLm51N7gAozMmSdy32vGy9fJntRkeQ8BWoS7XYqOHPG23cZ53JfDorOnSOP2y37XO4wGsklCP6cyTmXO02mkN8T8pedhAR7Y6rDaKRZgD8x4YpVu20lN3CxrFtJvNKbBVnVzccaH2ustM3Hmvx4vk+IQvg+IcHBn6eXD/csOLhv8uGeBQf3TT58nxCV8bjdKDhxwn+zUrhi1W5bCSzrZtU3lj1XAsu6WfWNZc+VwLJuNX0rC5+EyES0WrEqJcV/h3O4YtVuWwks62bVN5Y9VwLLuln1jWXPlcCybjV9KwtfjuFIgl+2lA/3LDi4b/LhngUH900+fDlGZTwuF7L27fM/cx2uWLXbVgLLuln1jWXPlcCyblZ9Y9lzJbCsW03fysInITJx2e3YOGyYfzOZcMWq3bYSWNbNqm8se64ElnWz6hvLniuBZd1q+lYWvhzDkQS/bCkf7llwcN/kwz0LDu6bfG6o5Zhdu3bhgQceQOPGjaHRaLCuZKe3P2PHjh3o2LEjIiMj0aJFCyxatKjK+xmIx+XC5c2bg76EFmys2m0rgWXdrPrGsudKYFk3q76x7LkSWNatpm9lUXUSYrVa0a5dO6SWbKl7PS5evIj7778fffv2xZEjR/Daa69h1KhR2Lx5cxX39BouhwO7xo/37+cfrli121YCy7pZ9Y1lz5XAsm5WfWPZcyWwrFtN38pSbZZjNBoN1q5di4ceeqjS90yYMAEbNmzA8ePH/a89/vjjKC4uxqZNmyS1w5djgoNftpQP9yw4WPXN5BDxy/kCeFQ4pdptdkx55mn8c8lSRNeIDnv7rMK6b+0Ta6FhQlRY2wz1coz++m+pPuzbtw/9S4r/+Bg0aBBee+21SmOcTiecJZUHAe8kBABsZjMsJcdycIsiLqWlodnf/gZdRETYYtVu21rilTXMnimNV7NtJZ4pbZtlz1kcaxfybXhhxTFkmQTZbYaMh9/CuDWn1GufVRj27ZMHW2JQmway45R8T2whrqTL1CQkOzsbDRqUNrxBgwYwmUyw2+2Iji4/k50xYwamT59e7vUhycnQVVlPb1zuKakYyZEO9yw4WPHN1fg2WIZOA0XHQ2MugNaYrXaXOH8Rpj02Ef9MP379N4aQUO+xytQkJBgmTZqE8ePH+/9tMpmQmJiINSdPomGTJir2jC2sJhPuSUzEpvR0xDB0iVxNuGfBwZJvO88V4vU1p0AuD+5oHIfUYd1QO8YQ9n6w5Fl1gn3fXgx7i9kZGbg1OTl0HxiSMnghAACtXbv2T9/Ts2dPevXVV0u9tmDBAoqPj5fcjtIqui6nk47Nm+cvnRyuWLXbVlJtkmXdSuKVVjZlVfdfZaytOnCFmk/aQEkT0mj4V7+S0WTlY42xtlkZa9Wp7VBX0WVqs7KUlBRs27at1GtbtmxBSkpK2PrgEUWc/eYbeEQxrLFqt60ElnWz6hvLnishHLqJCJ/vOIc3vj0Kt4cwpEMTzB/RGdFa4mONsbaVwLJuNX0ri6pPx1gsFpw7dw4A0KFDB8ycORN9+/ZF7dq1cdNNN2HSpEnIyMjA4sWLAXgf0b399tvx8ssv4/nnn8f27dvxyiuvYMOGDRg0aJCkNvnTMcHB6hMLasI9C47q7JvHQ3g37SQW7b0EAHihV3NMuKcVtFqNqv2qzp5VZ7hv8rmhNiv77bff0KFDB3To0AEAMH78eHTo0AFTp04FAGRlZeHKlSv+9998883YsGEDtmzZgnbt2uGTTz7B/PnzJU9AQoHL6cShmTPhCnjiJhyxaretBJZ1s+oby54roSp1O11uvLLisH8CMuX+1ph0X2v/BISPNT7WwhXP8lgri6qTkD59+oCIyv3x7YK6aNEi7Nixo1zM4cOH4XQ6cf78eTz77LNh7TO53cjatw/kln+PsJJYtdtWAsu6WfWNZc+VUFW6zQ4Rzy86gLSjWYjQafDp4+0xqmfzsLQdDvhYkw/LutX0rSzVZrOycMGXY4KDX7aUD/csOKqbb3lmJ55duB8nMk2oYdBh7tOd0KtlPbW7VYrq5hkrcN/kc0Mtx7CIy+nEL++8E/QltGBj1W5bCSzrZtU3lj1XQqh1X8q34pE5e3Ei04Q6MQas+Hv3SicgfKzxsRaueJbHWllu+H1CQo7HA8vVq4DHE95YtdtWAsu6WfWNZc+VEELdxzOMeHbhfuRbBCTWjsbi57vh5roxYWk77PCxFv62WfU8xPDlGI4k+GVL+XDPgqM6+Pbz2Xy8sOQ3WAU3khvFY9HzXVA/Lrw1OuRQHTxjEe6bfPhyjMqwWvmQV5tkr9okq7pZ9cwX/+E/PsBzC/fDKrjR45Y6WPlCd0kTED7W+FgLVzzLY60sfDmGw+GEFLPDhYOaujCfzIXOIL+InN1mh9AyBVtO5yO6hlVWrFsQcVpTL+i2T6QX4XP97YCHcH/bRpj5aDtE6nmVKQ6nqvjLLsdcPnsWN7Vo4Z8J6qOi4LLbAa0W+shIiDYbNDqd99hqhTYiAjqDwXtsMEAXEQHBYoE+KgpavR6C2Qx9dDS0ej2cJhMiYmKg1engNJlgiI0FNBoIZjMMcXEAEQSLBZHx8fC43RCtVu+xywWX3Q5DXJz32OGAITYWblGERxAQERMDtyDAI4qIiImBy+kEud2IqFHDe4ORxwN9dHSVaCq8ehX9ExOxy2hEBHBDaKrqPJkKCtCvcWPsyM1FjZiYG0LT9fJ0Jr0Azy09gkyj+r9hKWF4t0RMGdQChho1mMiTqaAAd9eti5+MRkRHRd2Q36eq0GR3ONC7bl1sz8hAQv36N4Smqs5TvtHIl2OCITU1FcnJyejSpQsA4MCUKQCAvZMnY+/kyQCAHWPH4rcZMwAAP44YgaOpqQCAtCFDcKpk19bV/fph3T33wGW3Y2W3bkgv2UZ+SevWyDlwAACwoGlTFJ0+DQCYm5AAS2YmBLMZcxMS8OOIETCeP4+5CQkAgKLTp7Gg5N6UnAMHsKR1awBA+rZtWNmtGwDgwrp1WNO/P1x2O9bcfTe+f+ghAMDR1FT8OGIEAOC3GTOwY+zYSjW57HYsbdMGR2bNKqdpTf/+uLBuHQBUqmlFcjISSrwsq0kwm2HJzKxU0+JWrbB11Chc2rixnCYAOLV4MdKGDKlUk8tux4rOnfHzm29KzpNPk8tux4LERFzauFFWngI1bR01CnlHjkjOk0/TtqefBgCcnDdPcp4CNbnsdvzvtttwYv58yXnyaXLZ7ZibkADj+fOS8xSoaUXXrtg6ahTOrlolOU+HrhRhyOzdyDQ6UNNtxy1CPm7TmNE5qRaa23PQKsKGzkm1cLMlE8lRAjon1UIzYzraxLjROakWbiq8iDsSgA5N49Hg6gncnqBB56RaaJJ1Gu3qRaJzUi00vnoCHRrVQMem8Wh89QQ6No1Hh0Y10PjqCXROqoW2dSLQOOMUOiUmoG1tPRJzz6FzUi3ckQDcVHgRnZNqoU2MG82M6eicVAvJUQJutmSic1IttIqw4RZbNp60HMGgAyux65VXJOXJN/ZOzJ+PraNGYXW/fpLzFDj27Lm5mJuQAHturuQ8+cbe5bQ0DAQk5akiTfvffRdbR43C5qef/tPvU0WaMn/+GVtHjcJXEr9PZTVl/vwz5jVsCJfd/qffp4o07X/3XSxr3x4uu132uXxN//64nJYGAFh/992yz+X23FxseuqpoM7lAHBi/nz877bb4LLbZZ3LAWDz00/j21694LLbZZ/LFzRtirwjR7B11CjZ53KfppASkgo0DOErYHf57FkiIhLtdhLtdu+xzUaiw0FERILVeu3YYvEX+rEVFNCeKVNIdDjIaTaTWxSJiMhpMvmPHUYjuV0u/7HH7SaPx0PW3FzaO3UqCTYbOUqK/7hdrmvHokhOk+nasdlMREQuQSDBYiHR4aA9U6aQraDA21+HgwSr1X8s2myVahIdDvp58mR/W4GaBIuFXILg1VGJpoL0dOpQUugpUJPDaCSPx0Met7tSTda8PNo3bRo5LZZymoi8xZR8xxVpEh0O2vPWW2QvLpacJ58m0eGgnydNImfJ50vJU6Ama26ut+9Wq+Q8+TQVZmZSe4CKc3Ml5ylQk6/vjpK2pOTJp0l0OGj3xIkk2GyS8xSoyZqfT/umTSOH2SwpTz8euUK3TdlISRPS6IFZO2jz1PfIXlQkOU+BmsxGI3UGyFgyzqXkyafDabXS7okTSXQ4JOcpUJOtsNCr22iUnCefDofJRPumTSNbQYHkPAVqEux2b87sdsl58mky5udT55Lv5/W+TxVpchiN3r4XFkrOk0+T02KhfdOmkTU3V3KeAjU5LRb6OTBnMs4RDqOR9kye7NUm81wuWCxkzM+n9gAVZmTIOpc7jEYS7HbaO3UqWXNzJecpUJPDZKKfJ03yf9flnCNshYW05623vHEyz+UOo5GcVqs/Z3LO5U6TKeQF7P6yyzH86Rh58LvI5fNX8WzVb+mYtOYY3B5C75b18PlTHRETGfztZn8V30IJ9yw4uG/y4U/HqIxos2HDsGEQbbawxqrdthJY1s2qb+HQTSXVZN8sU03W4BaY9ExpPB9r7HmuBJZ1q+lbWfjTMTLR6HRolJICjU7+HfNKYtVuWwks62bVt6rW/WfVZF2MeqY0no819jxXAsu61fStXF/4cgxHCvyypXxuVM+cLjdeX/U70o5mAfBWky1bzE0JN6pvVQn3LDi4b/LhyzEqI1qtWDtoEESrvP0LlMaq3bYSWNbNqm9VpVtKNVlWPVMaz8cae54rgWXdavpWFr4cIxNtRARuHTYM2gj5GyEpiVW7bSWwrJtV36pCt9Rqsqx6pjSejzX2PFcCy7rV9K0sfDmGIwl+2VI+N5Jnl/KtGL5gP64U2lAnxoCFz3VB26Y1q6StG8m3cME9Cw7um3z4cozKiFYrVqakBH0JLdhYtdtWAsu6WfUtlLqPXTVi6Ny9uFJoQ2LtaHz7Uo8/nYCw6pnSeD7W2PNcCSzrVtO3svDlGJloDQZ0HD8eWoMhrLFqt60ElnWz6luodO+9Ysbor4/IqibLqmdK4/lYY89zJbCsW03fysKXYziS4Jct5cO6Z+t/z8Trq45AdBN63FIHXzzTCXFRVb+GzLpvasA9Cw7um3z4cozKCBYLlrRpA8FiCWus2m0rgWXdrPqmtN9fbjuNV74+DNHtrSa78LkukicgrHqmNJ6PNfY8VwLLutX0rSx/2UmIrzqhy+G4dmy3eysYwrujnP/YaoVbEAAA5Hbjrg8/hD4qCoLFAo/LBQAQzGb/sdNkgsft9h+TxwMigkcQ0POTT6AzGOA0mQAAHrf72rHLBcFsvnZcMkDcogjRaoU+Kgp3ffABqOSzXU6nf8c7l9PprbJYiSZ9VBR6/Pvf0Gg05TSJVivcoujVUYkmwWSCpsS7QE1OkwlEBPJ4KtXkEUX0mjnTW82xjCYAcAuC/7giTfqoKNz5/vvXcichTz5N+qgo9PjXv6DV6yXnKVCTRxC8fY+IkJynsprcMvIUqMmfM61Wcp58mvRRUUh57z3oDAbJeRLMZhARZmw4iX9vOQ8AeKZrU8wc3BKRet118+TTBAC9Zs4EiCTnqawmfUmfpObJp0MbEYGU996DPipKdp5cTifI40GvmTOh0Wgk58mnQ6PVotfMmSC3W3KeAjXpIiO9OYuMvG6eymryiKJ/bV1qngI1aTQab989Hll5EsxmaPV69Jo5Ex5BkJynQE1avR4p//zntZzJOEdoNBrcOWOGt8qszHO5aLXCU6JJlHkud5pM0EVGoufHH8NT8nlyzuUAoNFq0ePf//b2XeY5gjwe3Pn++9BHRck+lztNJmgjIvw5k3Mu92kKKSGpQMMAs2fPptatW1PLli0JAH372GNERLRz3DjaOW4cERFtGTmS9k2bRkREaUOH0sFPPiEiojUDB9KxefOIiGhF9+70x6pVRES0ODmZLm3aRERE85s0ocy9e4mI6PO4OMo/fpyIiGYBZEpPJ4fRSLMAchiNZEpPp1kl1ucfP06fx8UREVHm3r00v0kTIiK6tGkTLU5OJiKiP1atohXduxMR0bF582jNwIFERHTwk08obehQIiLaN20abRk5sso0pcbFUZ+SAlk3iqaqztM3/fpRe4D2/utfTGj6omkijVt5mJImpFHShDSavf0snVkZ/jyZjUb6F0DntmwJS55uhLF3dNEimlzy/bxRNIUjT0cXLaL2AC1q1eqG0VTVeQp1Abu/zCTEh9IqupasLJrXuLG3eqTMKrrmq1dpXuPG5CguDqqKrtNkonmNG5MlK8vbXxmVF50mE81r1IhseXnlNFV1FV1zRgbNb9KE7IWFQVXR9en2VauUU0XXp9teWCg5T4GazFevevteVBT2Krr+nOXnS86TT5Mv1lFcLClPZqudnvlyDyVNSKPmkzbQki3HaH6TJmQrKJCcJ58ma24uzW/ShKw5OWGvomsvKqJ5jRr5PZFbRdeSne3VnZcnu4quLT+f5jdpQpasrKCq6DqMRm/OAv5dNk9VVUXXlpfn7Xt2tuwquvbCQprfpAmZr14NqoquvbCwdM5knCNseXn+83G4q+g6jEaa17gxma9elZynQE22/Hy/brlVdC3Z2X7dwVTRtRcV+XOmdhXdv+wkJCM9Pah4tyhS5t69/oSGK1btts1GI7UvOcmFu21WPVfimdK25cQWWJz04OyfKWlCGt02ZSNtPZnNxxofa2GJVbttPtbkx4d6EsKfjuFIgt9FLh8WPLtaZMPwBftxIc+KmjUi8NWILuiUVEvVPrHgW3WDexYc3Df58KdjVMZpMmFOfLz/Zp1wxardthJY1s2qb1JiT2eb8MicvbiQZ0XjhCh8+2KKfwLCxxofa+GIVbttJbCsW03fyhGS6ykMoXg5xuWi/OPH/euE4YpVu21Fly0Z1q0kXvEl8irU/cv5fLp92iZKmpBGA2buoMxiW9javh58rN1YY606t83Hmvx4vhyjEL4cExz8sqV8qqtnm45n4ZUVRyC4POjSrBbmD++ChBrqF7LyUV19q85wz4KD+yYfvhyjMk6TCZ9qNEFfQgs2Vu22lcCyblZ9qyx26S+XMXrZIQguDwYkN8CSkd0qnIDwscbHWjhi1W5bCSzrVtO3coTkegpDKF2O8bjdZEpPJ4/bHdZYtdtWctmSZd1K4pVeIg+lbo/HQzN/POPfA2Ti6t9JdFX+uXys8bEWjli12+ZjTX58qJdjeAE7uWg0MMTHAxrN9d8byli121YCy7pZ9S0g1u0hTFl3HF/vvwIAeOXuWzGu/63+3XOrsu2ww8da+Ntm2XMlsKxbTd/KwJdjZCKYzZibkBDU9rVKYtVuWwks62bVN1+sqbAYLy09iK/3X4FGA7z30O0YP6Dln09AQtQ2a54pjf+rjzUWPVcCy7rV9K0s/MZUmRARBLMZhri4657IQxmrdttKbuBiWbeSeKU3vSnVnZ9XhNFrTuPApSIYdFp8+nh73HtHo7C0zcfaX2usseo5H2vy4/mNqWpDBMFkAoKZuymJVbttJbCsm1HfsovteGLRYRy4VIS4SD0Wj+wqeQKitG1WPVMc/xcda0x7rgSWdavpWxn+spOQYKvoWnNysCAxEYLFIruKriUzEwsSE+E0mWRVyPRVXhQsFixITIQ1J8fbXxmVF32x9oKCcpqquoquJSsLCxIT4SguDqqKrq/vtvx8yXnyafLFOoqLJecpUJMvZw6jUVaFzFBU0fXnrLBQcp6cJhPOZhvxyJy9OFfoQL3YCKx4oTs61I2QXCHT43LBmp3tbbuoSHKefJps+fnefOXlhb2KrsNo9H8/g6mia83N9X9P5FbRtRcW+r+fwVTRdZrN3vOD2Rz2Krr2ggJv33NzZVfRdRQXY0FiIiyZmUFV0fXF+3Mm4xzh67dgsYS9iq4vX5bMTMl5CtTkGy+CxSK7iq5vnAoWS1BVdH3fE0tmpupVdP8yk5DU1FQkJyejS5cuAIADU6YAAPZOnoy9kycDAHaMHYvfZswAAPw4YgSOpqYCANKGDMGpxYsBABuGDMF9q1YhMj4eK7t1Q/q2bQCAJa1bI+fAAQDAgqZNUXT6NABgbkICLJmZEEoG7ItGI0SLBXMTEgAARadPY0HJslDOgQNY0ro1ACB92zas7NYNAHBh3Tqs6d8fkfHxuHvePGx59lkAwNHUVPw4YgQA4LcZM7Bj7NhKNUXGx6PF0KE4vWRJOU1r+vfHhXXrAKBSTSuSk5FQ4mWgJt+6oiUzs1JNq7p1w6tEyD1woJwmADi1eDHShgypVFNkfDw6jBuHg++/LzlPPk2R8fGonZyM3BIdUvIUqGlBYiJeJYItM1Nynnyatj39NADg5Lx5kvMUqCkyPh43DRzoz42UPL3XqQ+Gfr4XmSYnahVcxZIhLdAiViMpT4Ga1g4YgFeJkLF9u+Q8+TQdfP99vEqEfW+9JTlPZTU9DCDv0CHJefJpsmVmwhAXh8j4eMl5CtS0c+xYvEqEo6mpkvPk03Rh3Tq8SoQNJcd/lqeKNPkui2s0Gsl58mm6nJaGgYCsPAVqOpqaileJsLPkWGqelrRujeIzZ/AqEZYmJ0vOU6Cm4jNnENukCSLj4yXnyafpaGoq2owcicj4eNnn8jX9++NyWhoAYP3dd8s6l89NSIBGo8Hz6elYkJgoOU+Bmi6sW4ebBg5EZHy8rHM5AOwcOxY9P/kEkfHxss/lC5o2hS0zE68S+SciUs/lPk0hJSTP2DCE0iq6DqORcg8f9lYqlVlF115YSHnHjpFLEIKqout2uSjn8GH/++VUXnS7XJR94ID//eGsomsvKqL848e9lWGDqKLrdrko5+BBcvreI6OKrtvloqz9+/3vkZKnQE32wkJv353OsFfRdbtclL1/Pwkl779enradyqbb3tpISRPSaPB/d9OJnXvJJQiyKmT6c1ZcTPnHj5Ngt8uuouu0WCj/+HFyms1hr6IrOp2U+csv5Ha5gqqi6zCZvLqtVtlVdAWbjfKPHyeH0RhUFV2XKFLmL7+QSxTDXkVXsFq9fS+p6ColTz5NosNB+cePk72wMKgquqLDQVm//notZzLOEYLVStm//UZulyvsVXRdokh5R4/6K3TLraIr2GyUvX+/t+8yq+g6TCbKOXSI3C5XUFV0RafTnzNeRTfMKN0nxGE00udxcf7EhCtW7baVPE/Psm4l8Ur3bpDT9soDV6j5pA2UNCGNhn/1KxXmFTLrOR9r1XushTJW7bb5WJMfz7dtVwjftj04+PbG8gmHZ0SEOTvP48NNZwAAQzo2wQePtEWEjt2VVj7W5MM9Cw7um3z40zEq43G5kLVvn/8mn3DFqt22EljWXZ1983gI078/6Z+AvNC7OT4Z1g4ROi3TniuBZd2s+say50pgWbeavpWFT0Jk4rLbsXHYMP/dy+GKVbttJbCsu7r65nS58cqKw1i09xIAYMr9rTHp3tb+mxtZ9lwJLOtm1TeWPVcCy7rV9K0sfDmGIwl+2VI+VeWZ2SHixaUHsedcASJ0Gnw8rB0ebN8kZJ+vNnysyYd7FhzcN/nw5RiV8bhcuLx5c9CX0IKNVbttJbCsu7r5lmd24vEvf8GecwWoYdDhqxFdKpyAsOy5EljWzapvLHuuBJZ1q+lbWfgkRCYuhwO7xo/3byATrli121YCy7qrk2+X8q14ZM5enMg0oU6MASv+3h29WtaTFKu07XDFKoVl3az6xrLnSmBZt5q+lYUvx3AkwS9byieUnh27asRzi/Yj3yIgsXY0Fj/fDTfXjQlRT6sXfKzJh3sWHNw3+dxwyzGpqalo1qwZoqKi0K1bN+zfv/9P3z9r1izcdtttiI6ORmJiIsaNGwdHGGdzblHE2W++8W+NG65YtdtWAsu6q4NvO09l4/Ev9yHfIiC5UTxWv9TjuhMQlj1XAsu6WfWNZc+VwLJuNX0ri6qTkJUrV2L8+PGYNm0aDh06hHbt2mHQoEHIzc2t8P3Lly/HxIkTMW3aNJw6dQpfffUVVq5cickl29qGA48g4NDMmfCU7NUfrli121YCy7rV9m3Bkk0YteQQrIIbPW6pg5UvdEf9uChJsax6rgSWdbPqG8ueK4Fl3Wr6VhZVl2O6deuGLl26YPbs2QAAj8eDxMREjB07FhMnTiz3/jFjxuDUqVPYVrIfPgC8/vrr+PXXX/Hzzz9LapMvxwQHv2wpH6WeLfj5It5NOwkAuL9tI8x8tB0i9bpQd7PawceafLhnwcF9k0+ol2P0139L1SAIAg4ePIhJkyb5X9Nqtejfvz/27dtXYUyPHj2wdOlS7N+/H127dsWFCxewceNGPPPMM5W243Q64SypPAh4JyEAYDObYSk5loNbEPDH11+j5RNPQGcwhC1W7batJV5Zw+yZ0ng121bi2e7zhf4JyBMdGmDSPbdAtFkh9eIpy57zsRbesaa0bZY952NNfrwtxJV0VbsSkpmZiSZNmmDv3r1ISUnxv/7mm29i586d+PXXXyuM++yzz/CPf/wDRASXy4UXX3wRc+bMqbSdd955B9OnTy/3+h0AbvzfKTksQhotTM//F566SYg8mIborXOhUbtTHA6HA8AN4BjA/pWQYNixYwf+/e9/4/PPP0e3bt1w7tw5vPrqq3jvvffw9ttvVxgzadIkjB8/3v9vk8mExMRErDl5Eg2b3DgbPFU1VpMJ9yQmYlN6OmL4ZUtJBOvZN4ezMP2Hc6gZrcfGZf9CfNQHVdjL6gcfa/LhngUH900+2RkZuDU5OXQfGJIyeEHgdDpJp9PR2rVrS70+fPhwGjx4cIUxd911F/3jH/8o9dqSJUsoOjqa3G63pHaVVtEVHQ46+Mkn/pLK4YpVu20l1SZZ1q0kPhjPzA6ROr23hZImpNH8HX8wqZuPNTbGWqjaZtlzPtbkx4e6iq5qT8cYDAZ06tSp1E2mHo8H27ZtK7U8E4jNZoNWW7rLOp13UYXCtKpEbjey9u0Dud1hjVW7bSWwrDvcvn256wLyLU40q1MDj3dsxKRuPtbYGGuhaptlz5XAsm41fSvfGRVZsWIFRUZG0qJFi+jkyZP097//nWrWrEnZ2dlERPTMM8/QxIkT/e+fNm0axcXF0ddff00XLlygH3/8kW655RZ69NFHJbep9ErIXxWlv2n9FZHrWVaxnW6bspGSJqTRxqOZVdy76gsfa/LhngUH900+N8yVEAB47LHH8PHHH2Pq1Klo3749jhw5gk2bNqFBgwYAgCtXriArK8v//ilTpuD111/HlClTkJycjJEjR2LQoEH44osvwtZnl9OJX955B66AJ27CEat220pgWXc4fZu55QwcogedkmrhntsbMqubj7XqP9ZC2TbLniuBZd1q+lYW1W9MHTNmDMaMGVPhz3bs2FHq33q9HtOmTcO0adPC0LNK8HhguXoV8HjCG6t220pgWXeYfDuVZcI3B68CAN66vzU0Gg27uvlYC3/bSmFVN6ueKY1neayVgdeO4UiCb+ojHzmeDV+wH7v+yMP9bRsh9cmOYeph9YSPNflwz4KD+yafG652DGuwWvmQV5usvtUmd/6Rh11/5CFCp8GEQa1C0jbLniuBZd2s+say50pgWXd1qqLLJyEcjoq4PYQZG08BAIanNMNNdWqo3CMOh8MJH3w5hiMJftlSPlI8W3UgHW+uPor4KD12vdkXNWvI34L5RoOPNflwz4KD+yYfvhyjMi67HVtHjYLLbg9rrNptK4Fl3VXpm01w4ZMtZwAAr9x9a7kJCKu6+VirfmOtKttm2XMlsKxbTd/KwichctFqEdu0KaANwjolsWq3rQSWdVehb/N3X0SOyYnE2tF4JiUptG2z7LkSWNbNqm8se64ElnWr6VtZQrLbCEP4Niu7fPYsERGJdjuJdrv32Gbzb2MrWK3Xji0Wcjmd144FgYiInGYzuUXRe2wy+Y8dRiO5XS7/scftJo/H4z32eMjjdpOjZKMXt8t17VgUyWkyXTs2m4mIyCUIJFgs3mOn038sOhwkWK3+Y9FmqzJNBenp1KFkU58bRVNV56kwM5PaA1Scm1tOU47JTq2n/EBJE9Jo/ZEMZjSFI09mo5E6A2QsKLhhNFV1noz5+dS55Pt5o2gKR56M+fnUHqDCjIwbRlNV5+mG2qwsnKSmpiI5ORldunQBAByYMgUAsHfyZOydPBkAsGPsWPw2YwYA4McRI3A0NRUAkDZkCE4tXgwAWN2vH77t1QuizYaV3bohvWTb+SWtWyPnwAEAwIKmTVF0+jQAYG5CAiyZmRDMZsxNSEDaww+j+Px5zE1IAAAUnT6NBSX3puQcOIAlrVsDANK3bcPKbt0AABfWrcOa/v29bfboge8ffBAAcDQ1FT+OGAEA+G3GDOwYO7ZSTaLNhv+1bInD//lPOU1r+vfHhXXrAKBSTSuSk5FQ4mVZTYLZDEtmZqWaFrdqhQ3DhuHihg3lNAHAqcWLkTZkSKWaRJsNS9u2xc9vvCE5Tz5Nos2Gr5o0wcUNG2TlKVDThmHDkHf4sOQ8+TRte/ppAMDJefPKaZq19Sxsohu3eIz4W9tGFWoSbTYsvOUWHJ8/X3KefJpEmw1zExJQfP685DwFalrRtSs2DBuGP1aulJwn39j7+Y03sGHYMGx/6SXJeSqr6WEAeYcOycoTAOQdPowv6tSBaLNJzlOgps1PP40Nw4bh13ff/dPvU0Wajs+fjw3DhmF1v36S8xSoyZaTg7kJCbDl5EjOk0/T5bQ0DARk5SlQ06/vvosNw4Zh89NPy8rTktatkbF7NzYMG4avZOQpUFPG7t34skEDiDab5Dz5NP367rtYkpwM0WaTfS5f078/LqelAQDW33237HO5LScH6x94IKhzOQAcnz8fC2+5BaLNJutcDgCbn34aK7p2hWizyT6XL2jaFHmHD2PDsGGyz+U+TSElJFMZhlB6JcRWUEAHPvyQRIdD9kzTmptLv338MQk2W1CzZ9HhoAMffEC2kt8Q5cyeRYeD9s+Y4W8rnFdCrHl5dPCTT8hpsQT1G4HocNCB998ne3Gx5Dz5NIkOB+3/97/JWfL5cn8jsObmevtutYbsSsjJy3l088Q0SpqQRvtOZ1Wqydd3R0lbcn7LER0O+vVf/yLBZgvqNzdrfj4d/OQTcpjNsn9zsxcX08FPPiF7UVHYr4Q4rVb69V//ItHhCOq3UVthoVe30Sj7t1GHyUQHP/mEbAUFQf02Ktjt3pzZ7WG/EuIwGr19LyyU/Ru202Khg598Qtbc3KB+w3ZaLKVzJuMc4TAaaf/773u1hflKiGC3028ffUTW3FzJeQrU5DCZaP+//+3/rsu5EmIrLKQDH3zgjQviSojTavXnTO0rIfzpGI4k+F3k8qnMs+cXHcD207kY1KYBvnims4o9rJ7wsSYf7llwcN/kw5+OURnRasXaQYMgWq1hjVW7bSWwrDvUvu09l4/tp3Oh12ow4Z5Wf/peVnXzsVY9xlq42mbZcyWwrFtN38rCJyEy0UZE4NZhw6CNiAhrrNptK4Fl3aH0zeMh/KtkY7Knuyeheb3YKmubZc+VwLJuVn1j2XMlsKxbTd/KwpdjOJLgly3lU9azNYeuYvyq3xEXqcfON/uidgzfmKwi+FiTD/csOLhv8uHLMSojWq1YmZIS9CW0YGPVblsJLOsOlW8O0Y2PNns3Jhvdt4WkCQiruvlYU3eshbttlj1XAsu61fStLHwSIhOtwYCO48dDa5D/W6ySWLXbVgLLukPl21c/X0SW0YEmNaPx3J3Nqrxtlj1XAsu6WfWNZc+VwLJuNX0rC1+O4UiCX7aUj8+z7zLzcN/cg7A4XZj1WHs81KGJ2l2r1vCxJh/uWXBw3+TDl2NURrBYsKRNGwgWS1hj1W5bCSzrDoVvc36+AovThdubxGNwu8ZhaZtlz5XAsm5WfWPZcyWwrFtN38oRkt1GGMK3WVlGenpQ8W5RpEubNvk3fglXrNptm41Gal+yGVK422bVc7PRSHfUbkLNSzYm23MuL2xts+w5H2vBjbVgPVPaNsue87EmP171zcoWLlyIxx57DDVq1Aj9jCgM8OWY4OCXLeVjMZnQ4dkPIbZMQf/W9TF/RBe1u8QEfKzJh3sWHNw3+ai+HDNx4kQ0bNgQI0eOxN69exV3gDUEsxlfNW0KwWwOa6zabStBTd0FeUV4s/v9+P7ARWw6niX7z/cHLuIfKQ8EFb/sQAbElinQaYCJ9/75xmSh1s3HGnu6WfWNZc+VwLJuNX0ri15uQEZGBr7//nssWrQIffr0QfPmzfHcc89hxIgRaNiwYVX0sUpwORyl/tZHRcFltwNaLfSRkRBtNmh0Ou+x1QptRAR0BgPI48E9X38NfXQ0BIsF+qgoaPV6CGYz9NHR0Or1cJpMiIiJgVang9NkgiE2FtBo4BFF3LtqFXSRkXCaTIiMj4fH7YZotXqPXS647HYY4uK8xw4HDLGxcIsiPIIAfXQ0Bi1fDvJ4vH13OkFuNyJq1IDL6QQ8HuijoyvWFB2NgUuWQFNSujlQk2i1QmswQBcRUakmwWSCpsS7QE2C2QxDXBxABMFiqVCTx+XCfd98A23J5wdqioiJgVsQ4BFFRMTEVKpp0NKlgMbbAyl5Eq1WXDSKePZ/h5DZZzRWrT4Z/GDp/SK+VRA/pG19JMXq/Dn70zwFaoqOxsDFi6HR6a7l7Dp58o09fXQ0BixaBF1kJIhIUp4Cx57H7cZ933wDjV4P0WqVnCeXwwFoNLjvm2/8eq+Xp7KaAO+JyeNyAUCl36eKNGkNBgxYtAj66Ojrfp8q1ETk1a3VwmW3S8tTiSaNTof7vvkG5PHALYqS8hSoSRcV5c1ZVBTI45GUJ58mjyj6T+aS8xSgSaPVevtOdC1nEs8R2ogI3PfNN/CIIjxut6Q8BWrSRkSUzpmUPJVo0mi1GLh0qaw8BWryiKL3u2WxwFOjhuRzue89965c6f8MOefyiJgYaHQ6DFy82Nt3Oefyku/0oGXLoI+Oln0ud5pM0EVG+nNGHo/kc7nLbg/6PFgZsq+E6PV6PPzww/juu++Qnp6O//u//8OyZctw0003YfDgwfjuu+/gKflPsjoRqiq66+65B7bsbGj1etlVdL+oUwd1br8dttzcoCovavV6FP/xBzY++igAeVV0tXo9jn7+OY598UU5TVVdRXfZHXegUUoKMnbuDKqKrlavx4X16/HL1KmS8/Sfh0fgkdSfkWl0IM5uxB0JQOekWkjMPYe2tfXonFQLTbJOo129SHROqoXGV0+gQ6Ma6Ng0Ho2vnkDHpvHo0KgGGl89gc5JtdCuXiSaZJ1G56RaaFtbj8Tcc+icVAt3JAA3FV5E56RaaBPjRjNjOjon1UJylIBm5gxE/LEP/c9vl1Uh06dJq9fjtw8+wJnlyyXnyTf2tHo91g4YAFtublBVdL+58040SknBpbQ02VV0f5k6FY1SUrBr3LiwV9E1njuHDUOGQKvXB1VFd+vIkWiUkoKDH30ku4rumeXL0SglBevuuSeoKrouux1rBwyAy24PexXdgx99hEYpKdg6cqTsKrp5hw+jUUoKFjZrFlQV3bzDh7Hl2Weh1etlV9E9+NFHOLN0KbR6fdir6LrsdsQlJeGLOnUk5ylQ05nly/HbBx94z80yq+huHTkSuQcPQqvXB1VF13juHBqlpOCLOnXYr6L7yy+/0N///neKjIykZs2aUUJCAjVr1ox++uknpR9dJSitomvOzKTU2FhvJUKZVXRN6emUGhtL9qKioKroOoxGSo2NJXNmpre/Miov+mJ9FR/DWUXXdPUqfR4XR7aCgqCq6Pr6bsnJkZSnbaey6ba3NlLShDR64NOd9FHdRv7Kw3Kr6JrS0719LywMWRVdqdVZ/TnLy5OcJ58mX6y9qCioKrrmjAz6PC6OrPn5sqvoWnJy6PO4OLJkZ4e9iq6tsND//Qymiq45K8urOzdXdhVda14efR4XR+bMzKCq6NqLi705Ky4OexVda26ut+9ZWbKr6NoKCujzuDgypacHVUXXVlBQOmcyzhHW3Fx/bLir6PryZSp5yEFuFV1rXt61vsusomvOyvLHBlNF11ZY6M+Z2lV0g5qEZGdn00cffUTJyckUFRVFjz/+OG3ZsoWIiCwWC7355pt00003haSDoUbx0zEuF+UfP+4fmOGKVbttRXeRh1H3ygNXqPmkDZQ0IY2Gf/UrmawO1TxX/MQCH2thb5tVz/lY42MtXPGqPx3zwAMPYPPmzWjZsiVGjRqF4cOHo3bt2qXek5ubi4YNG1bLZRn+dExwVPe7yIkIc3aex4ebvFujD+nQBB8MbYsInXpb4VR3z6or3Df5cM+Cg/smH9Wfjqlfvz527tyJ48eP47XXXis3AQGAevXq4eLFi4o7Vx1xmkz4VKOB02QKa6zabSuhqnV7PITp35/0T0Be6NUcHw9rhwidVlXPlcLHmnxY1s2qbyx7rgSWdavpWzlCcj2FIZQux/juE/C43WGNVbttJZctq1K3Q3TRy8sOUtIE74Zg83adD1vb10PpJXI+1qrXWKvObfOxxsdauOJDvRwj+0rIK6+8gs8++6zc67Nnz8Zrr72maELEBBoNDPHx/sdFwxardttKqCLdZoeI5xcdQNrRLEToNPj08fYY1bN5WNoOC3yshb9tVj1XCqu6WfVMaTzLY60Msichq1evxp133lnu9R49euDbb78NSaeqM4GPMoUzVu22lVAVuvPMTjz+5S/Yc64ANQw6fDWiCx5sX74wnJqeK4WPNfmwrJtV31j2XAks61bTt7LIvjE1KioKx48fR4sWLUq9fu7cOdx+++1wlGyuUl1RemMqBWz8pJE5i1QSq3bbSm7gCrXuS/lWDF+wH1cKbagTY8DC57qgbdOaYWlbDkpveuNjTf2xxkrbfKzxsRaueNVvTG3RogU2bdpU7vUffvgBzZs3ryDiBoMIgskEyJu7KY9Vu20lhFD3satGDJ27F1cKbUisHY1vX+pR6QQk1G2HHT7Wwt82q54rhVXdrHqmNJ7lsVYG2ZOQ8ePH480338S0adOwc+dO7Ny5E1OnTsXEiRMxbty4quhjtUKwWLAgMTHo8svBxqrdthJCpfunY+l4/Mt9yLcISG4Uj9Uv9cDNdWPC0jZrvvGxxp5uVn1j2XMlsKxbTd/KIns5BgDmzJmDf/3rX8jMzAQANGvWDO+88w6GDx8e8g6GGr5PSHCo/Tz9+t8z8fqqIxDdhB631MEXz3RCXFRE2PshB7U9YxXum3y4Z8HBfZOP6ssxAPDSSy/h6tWryMnJgclkwoULF5iYgIQCj9uNghMn4HG7wxqrdttKUNr2/F3n8crXhyG6Cfe3bYSFz3WRPAFR03Ol8LEmH5Z1s+oby54rgWXdavpWFkXbSdarVw+xsbGh6ktYCayi6z+2270VDAGINtu1Y6sVbkEAANhyc7Gye3eIVisEi8Vf6VMwm0tV/fQl12kygTweEBGsWVlY2b07BLPZv0mMx+2+duxy+e9W9rhc/ktlblGEaLVCtFqxsnt32HJzvf11OiHabP5jX4XDijT5Yh2FheU0iVYr3CWVICvTVLaKrk+T02QCEYE8nko1WbOzsSolBU6jsZwmwFv103ccqEl0OPDv74/hnxu9BaSeal8f/328A3SicN08+TT5dDuNRsl5CtRkzcry9t1kkpynsprcMvIUqMmfs6IiyXnyafLFCmaz5DwFarLl5GBVSgocxcXXzVNZTfaCAqxKSYE9P19ynspqKltF93p58ulwmkz+76fcPLmcTtjy8ry6Cwsl58mnw1FUhFUpKbDl5krOU6AmwWLx5sxikZwnn6ayVXSl5ClQk6Ow0Nv3vDxZeRLMZjiNRqxKSYE1K0tyngI1OY3G0jmTcY5wFBb6Y+Wey8tV0ZVxLneaTP58WbOyJOcpUJOjqOha32WeI2x5ef5Yuedy37nMlzM55/KqeJomqEnIt99+i0cffRTdu3dHx44dS/2proSqiu6GIUMwYMECRMbHy66iuyAxESMzMiBaLEFV0Y2Mj0ev//wHW559FoC8KrqR8fFIuucenF6ypJymqq6iu6pbN7xkMiH3wAHJFTJFtwcj312JL/dcAQAMdZ3DwP1fQ6vVSK6QeWHdOkTGxyPuppuQW6JDaoVMn6YFiYl4yWSCLTNTVoXMU4sXY9vTTwMATs6bF1QV3cj4eDTq0cOfGzlVdCPj4yFaLBAtlqCq6K4dMAAvmUzI2L5ddhXdg++/j5dMJux7662wV9G1ZWZCo9EgMj4+qCq6O8eOxUsmE46mpsquonth3Tq8ZDJhQ8mxlDwFatJoNBAtFmg0mrBX0T2amoqXTCbsLDmWmqclrVuj+MwZvGQyYWlyclBVdIvPnEFkQgIi4+NlV9E9mpqKlo89hsj4+LBX0dVoNHjm1CksSEyUnKdATRfWrUOjHj0QGR8vu4ruzrFj0X36dETGxwdVRdeWmYmXTCYsSExkr4rup59+SrGxsTRmzBgyGAz0wgsvUP/+/SkhIYEmT54s9+PCjtIquo7iYrq6a5e/MqKcyov2ggLK2LOHXE5nUFV03aJI6Tt3kqO42NtfGZUX3aJIV7Zv91dwDGcVXXthIWXu3Uui3S6pQmZxkYlGLPiVkiakUfOJG2jFL5co/aef/LFSK2S6BIHcokiXt271+yG3iq69oMDb95KqtlLy5NOktIquWxTpyrZt/lg5VXTdokiXt2whl9MZVBVde1ERZe7dS4LNJruKrtNspsy9e8lpMoW9iq7ocNDlLVvILYpBVdF1GI1e3RaL7Cq6gtVKmXv3kqO4OKgqui5B8OZMEMJeRVewWLx9L6noKiVPPk2i3U6Ze/eSvaAgqCq6ot1eOmcyqugKFgtd+ekncoti2KvougSBMn7+mewl41RuFV3BaqUr27Z5+y6ziq7DaKT0HTvILYpBVdEVHQ5/zpironvbbbfR8uXLiYgoNjaWzp/3bpP99ttv08svvxySTlUlSrdtd5pMNL9JE/8AC1es2m0r2d5YTtsFFic9OPtnSpqQRrdN2UhbT2Yz67nSrbRZ1c3KWAt1PB9r7HnOx5r8eNWr6NaoUQOnTp1CUlIS6tevjy1btqBdu3Y4e/YsunfvjoKCgpBeqQk1/OmY4AjHXeRXi2wYvmA/LuRZUbNGBL4a0QWdkmpVSVvhgN95HxzcN/lwz4KD+yYf1Z+OadiwIQpLbm686aab8MsvvwAALl68CJnzGSbxuFy4vHmz/yafcMWq3bYSpLR9OtuER+bsxYU8KxonROHbF1P8ExBWPVcKq7pZ9UxpPB9r7HmuBJZ1q+lbWWRPQvr164f169cDAJ577jmMGzcOAwYMwGOPPYaHH3445B2sbrgcDuwaP95/x3K4YtVuWwnXa/vXCwUYNncfckxOtGwQi9Wje6BF/TjJ8Urarup4JbCqm1XPlMbzscae50pgWbeavpVF9nKMx+OBx+OBXu99IGzFihXYu3cvbr31VrzwwgswGAxV0tFQwZdjgqOqLltuOp6FV1YcgeDyoEuzWpg/vAsSalTvTcikwi/1Bgf3TT7cs+DgvslH1eUYl8uFf/7zn8jOzva/9vjjj+Ozzz7D2LFjq/0EJBS4RRFnv/nG/yx2uGLVblsJlbW99JfLGL3sEASXBwOSG2DJyG4VTkBY9VwprOpm1TOl8Xyssee5EljWraZvZZE1CdHr9fjwww/hqgbrSGrhEQQcmjkTnpLNYcIVq3bbSijbNhHhP1v+wJR1x+Eh4ImuiZjzVEdERegkxStpO9zxSmBVN6ueKY3nY409z5XAsm41fSuL7OWYBx98EEOGDMGIko1VWIMvxwRHqC5buj2EKeuO4+v93k3IXrn7Vozrf2tQ5airO/xSb3Bw3+TDPQsO7pt8VH865t5778XEiRPxj3/8A19//TXWr19f6o9cUlNT0axZM0RFRaFbt27Yv3//n76/uLgYL7/8Mho1aoTIyEi0bNkSGzdulN1usLgFAcfnz/dvkxuuWLXbVoKvbavVjpeWHsTX+69AowHee+h2jB/Q8roTEFY9Vwqruln1TGk8H2vsea4ElnWr6VtZZE9CRo8ejZycHMycORNPPfUUHnroIf8fuU/HrFy5EuPHj8e0adNw6NAhtGvXDoMGDUJuSW2UsgiCgAEDBuDSpUv49ttvcebMGcybNw9NmjSRKyNoPCVraZ4g1tKUxKrdthI8ooija77DiP8dxI8nc2DQafH5kx3xTPckyfEseq4UVnWz6pnSeD7W2PNcCSzrVtO3sshejgkl3bp1Q5cuXTB79mwA3idvEhMTMXbsWEycOLHc++fOnYuPPvoIp0+fRkREcE9Q8OWY4FBy2TLb6MCIBftxJseMuEg95o3ojO7N61RRT6sP/FJvcHDf5MM9Cw7um3xCvRyjv/5bqgZBEHDw4EFMmjTJ/5pWq0X//v2xb9++CmPWr1+PlJQUvPzyy/juu+9Qr149PPnkk5gwYQJ0uopvanQ6nXCWVB4EvJMQALCZzbCUHMvB5XTixLx5aPN//wd9ZGTYYtVu21rilVWmZxfybXjh62PIMguoFxOBOY/fjlZ1I2R5z6rnwXoWirb/imMtFG2z6jkfa3yshSveFuJKurKvhLz77rt/+vOpU6dK+pzMzEw0adIEe/fuRUpKiv/1N998Ezt37sSvv/5aLqZVq1a4dOkSnnrqKYwePRrnzp3D6NGj8corr2DatGkVtvPOO+9g+vTp5V6/A0DF0xZOqHA1vg2WodNA0fHQFlxF7Kqp0JkqXmrjcDgcTvXHDeAYELIrIbInIR06dCj1b1EUcfHiRej1etxyyy04VFJ++3oEMwlp2bIlHA4HLl686L/yMXPmTHz00UfIysqqsJ2KroQkJibi7MmTaBjGe0lYx2oy4Z7ERGxKT0eMhIG381whXl9zCg6XB3c0jkPqsGTUjrnx95EJRK5nHC/cN/lwz4KD+yaf7IwM3JqcHLJJiOwquhVhNBrp4YcfpsWLF0uOcTqdpNPpaO3ataVeHz58OA0ePLjCmF69etHdd99d6rWNGzcSAHKWlDKW0lcoqKIrOhy0b9o0f0nlcMWq3bacapOrDlyh5pM2UNKENBr+1a9kNFmZ1a0kXmllU1Z1h3OshbptVj3nY42PtXDFh7qKruynYyoiPj4e06dPx9tvvy05xmAwoFOnTti2bZv/NY/Hg23btpW6MhLInXfeiXPnzsHj8fhf++OPP9CoUaPw7dbq8cBy9SoQ0IewxKrdtgSICJ/vOIc3vj0Kt4cwpGMTzB/RGTX0GnZ1h8G3Kmn7Bh9rVdY2q54rhVXdrHqmNJ7lsVaWkExliGj37t1Us2ZNWTErVqygyMhIWrRoEZ08eZL+/ve/U82aNSk7O5uIiJ555hmaOHGi//1XrlyhuLg4GjNmDJ05c4bS0tKofv369M9//lNym0qvhPxVud5vDG63h6Z9d5ySJqRR0oQ0+vfGk+TxeMLcy+qF0t9O/6pw3+TDPQsO7pt8VL8S8tlnn5X68+mnn2LixIl47LHHcO+998r6rMceewwff/wxpk6divbt2+PIkSPYtGkTGjRoAAC4cuVKqXs9EhMTsXnzZhw4cABt27bFK6+8gldffbXCx3mrClYrH1Zl1USny41XVhzGor2XAABT7m+NSfe29m9CxrJuVqt0suy5EljWzapvLHuuBJZ1V6cqurIf0f3Pf/5T6t9arRb16tXDiBEjSj1uK5UxY8ZgzJgxFf5sx44d5V5LSUnBL7/8IrsdTtVgdoh4celB7DlXgAidBh8Pa4cH2/MbfjkcDodzfVTdrEwN+GZlwVHRpj55ZieeXbgfJzJNqGHQYe7TndCrZT2Ve1p94BshBQf3TT7cs+DgvslH9doxRqMRhYWF5V4vLCz0bwR2I+Oy27F11Ci47Pawxqrddlku5VvxyJy9OJFpQp0YA1b8vXulExCWdYfat3C1zbLnSmBZN6u+sey5EljWraZvZZE9CXn88cexYsWKcq+vWrUKjz/+eEg6Va3RahHbtCmgDeLBIiWxarcdwPEMI4bO3YsrhTYk1o7Gty/1QNumNauubVY9Vwqruln1TGk8H2vsta0ElnWr6VsZZC/H1K5dG3v27EHr1q1LvX769GnceeedKCgoCGkHQw1fjgkO32XLD49cwmurT8EquJHcKB6Lnu+C+nFRanevWsIv9QYH900+3LPg4L7JR/XlGKfTCZfLVe51URRhrwaXdqoa0WbDhmHDINpsYY1Vu20AEFr3wksrT8AquNHjljpY+UJ3SRMQlnWHwrdgYVU3q54pjedjjT3PlcCybjV9K4vsp2O6du2KL7/8Ev/9739LvT537lx06tQpZB2rrmh0OjRKSYGmkoJ5VRWrNN4iEtI7DsCPZwqgizDKjv/9Uj6sg98EPIT72zbCzEfbIVIvrR9q6lazbaWwqptVz5TG87HGnudKYFm3mr6V64vc5Zg9e/agf//+6NKlC+6++24AwLZt23DgwAH8+OOP6NmzZ5V0NFT4lmMunz2Lm1q08D8nrY+K8t6ko9VCHxkJ0WaDRqfzHlut0EZEQGcweI8NBugiIiBYLNBHRUGr10Mwm6GPjoZWr4fTZEJETAy0Oh2cJhMMsbGARgPBbIYhLg4ggmCxIDI+Hh63G6LV6j12ueCy22GIi/MeOxwwxMbCLYrwCAIiYmLgFgR4RBERMTFwOZ0gtxsRNWrA5XQCHg/00dHlNJ0vsOP5pUeQUaz8StWTnRvj7QHNERUXp6omFvJkKihAv8aNsSM3FzViYm4ITeHIk81mQ9+EBGwrKEB87do3hKaqzpOpoAB3162Ln4xGREdF3RCawpEnu8OB3nXrYntGBhLq178hNFV1nvKNRnWXY+68807s27cPiYmJWLVqFb7//nu0aNECR48erdYTkNTUVCQnJ6NLly4AgANTpgAA9k6ejL2TJwMAdowdi99mzAAA/DhiBI6mpgIA0oYMwanFiwEAq/v1w4rOnSFarVjZrRvSS7adX9K6NXIOHAAALGjaFEWnTwMA5iYkwJKZCcFsxtyEBKzp3x/F585hbkICAKDo9GksKLk3JefAASwpudcmfds2rOzWDQBwYd06rOnfH6LViuUdOuD7Bx8EABxNTcWPI0YAAH6bMQM7xo4tp+mrcVPxyOzdyCi2I9ZahNt0VnROqoWbLZlIjhLQOakWmhnT0SbGjc5JtXBT4UXckQB0TqqFxNxzaFtbj85JtdA08xTq/DgHkwY0x5c1a5bSJJjNsGRmVqppcatWWDtoEC5u2FBOEwCcWrwYaUOGVKpJtFqxuFUr/PzGG5LztKZ/f1xYtw6i1Yr5DRvi4oYNsvIUqGntoEHIO3RIcp58mrY9/TQA4OS8edfNU0WaRKsVC5KScHzevFKaAFx37IlWK+YmJKD43DnJeQrUtKJLF6wdNAh/rFghOU8+TT+/8QbWDhqE7S+9JDlPZTU9DCCvpBim1DyhJOaL2rUhWq2S8xSoafNTT2HtoEH4dfp0yXnyaTo+bx7WDhqE1f36Sc5ToCZbdjbmJiTAlp0tOU8+TZfT0jAQkJWnQE2/Tp+OtYMGYfNTT8nK05LWrZGxaxfWDhqEr2TkKVBTxq5d+LJePYhWq+Q8+TT9On06Ft16K0SrVfa5fE3//riclgYAWH/33bLP5bbsbHzbt29Q53IAOD5vHhYkJUG0WiXnyadp81NPYVnbthCtVsl5CtSUd+gQ1g4aJCtPgZpCSkj2XWUI37btl8+eJSIi0W4n0W73Htts/oI+gtV67dhiIVdJgTx7YSH9PmcOuZxOcprN5BZFIiJymkz+Y4fRSG6Xy3/scbvJ4/GQLS+Pjn75JYl2OzlKtrx1u1zXjkWRnCbTtWOzmYiIXILg78Pvc+aQvbDQ21+HgwSr1X8s2mylNG07lU23vbWRkiak0eDPdtHOTz/3f36gJsFiIZcgeHVUoqkgPZ06lGxvHKjJYTSSx+Mhj9tdqSZbfj4dmzePBKu1nCYiIpfT6T+uSJPL6aQjn3/u/0wpefJpcjmddPi///V/ppQ8BWqy5eV5+26zSc6TT1NhZia1B6g4N/dP81SZJpfTSUdmz/Z/vpQ8+TS5nE46/NlnJNrtkvMUqMlWUEDH5s0jp8UiOU8+TQ6jkY7Nm0eO4mLJeQrUZDYaqTNAxoICyXny6RBsNjr82Wfkcjol5ylQk72oyKvbZJKcJ58Op9lMx+bNI3thoeQ8BWoSHQ5vzhwOyXnyaTLm51Pnku+n1DwFanKaTN6+FxVJzpNPk2C10rF588iWlyc5T4GaBKuVDv/3v9dyJuMc4TSZ6EhqKrmcTtnncsFiIWN+PrUHqDAjQ9a53GE0kuhw0NEvviBbXp7kPAVqcprNdGT2bG/fJebJp8NeVES/f/653xc553KH0UiCzebPmZxzudNkCvm27bKXYzZu3AidTodBgwaVen3z5s3weDyyt24PN3+Vp2O++S0dE9ccg9tD6N2yHj5/qiNiImXfAuSH30UuH+5ZcHDf5MM9Cw7um3xUfzpm4sSJcLvd5V4norDWcFEL0WrFypQUiFZrWGOlxlPZSrYdvJVsDS6noraVEA7d1bFtpbCqm1XPlMbzscae50pgWbeavpVF9q/GZ8+eRXJycrnXW7VqhXPnzoWkU9UZrcGAjuPHQ2swhDVWSrzHQ3g37aS/kNwLvZpjwj2toNVq4FbYthKqWnd1bVsprOpm1TOl8Xyssee5EljWraZvZZG9HNOwYUMsX74c/fr1K/X61q1b8eSTTyI3NzekHQw1N+pyjNPlxuurfkfaUW/V4Sn3t8aons1D9vn8sqV8uGfBwX2TD/csOLhv8lF9OebBBx/Ea6+9hvPnz/tfO3fuHF5//XUMHjxYcYeqO4LFgiVt2kCwWMIa+2fxZoeI5xcdQNrRLEToNPj08fblJiBK21ZCVemu7m0rhVXdrHqmNJ6PNfY8VwLLutX0rRxy72QtLi6m7t27k16vp2bNmlGzZs1Ir9dT3759qaioKCR3y1YlvqdjMtLTg4p3iyJd2rTJf6dxuGIri881Oei+T3dR0oQ0av32D7TzTG6VtG02Gql9yd33oeh3uOLVbFuJZ0rbZtlzPtb4WAtX23ysyY9X/emYkokLtmzZgt9//x3R0dFo27YtevXqFdLJUVVxIy3HXMq3YviC/bhSaEOdGAMWPtflzwvJKYBftpQP9yw4uG/y4Z4FB/dNPqovxwCARqPBwIED8cYbb2DMmDHMTEBCgWA246umTSGYzWGNLRsvt5Kt0raVEErdLLWtFFZ1s+qZ0ng+1tjzXAks61bTt7IEtXGE1WrFzp07ceXKFQiCUOpnr7zySkg6Vl3RR0fjvm++gT46OqyxgfG/ZNjw0vLDsirZKm1bCaHSrabnrPnGsudKYFk3q76x7LkSWNatpm9lkb0cc/jwYdx3332w2WywWq2oXbs28vPzUaNGDdSvXx8XLlyoqr6GBNaXY9b/nonXVx2B6Cb0uKUOvnimE+KiIqq8XX7ZUj7cs+DgvsmHexYc3Df5qL4cM27cODzwwAMoKipCdHQ0fvnlF1y+fBmdOnXCxx9/rLhD1R2nyYQ58fFwmkyyY3NzCjC+bV98v/8CNh3Pkv3n47RjeOXrwxDd3kq2C5/rInkCoqTfSlHatpJ4NdtWCqu6WfVMaTwfa+x5rgSWdavpW1lkL8ccOXIEX3zxBbRaLXQ6HZxOJ5o3b44PP/wQI0aMwJCSIkPVHV91QrlVCgFg6K5diIiJkV2l8LW1p7D3vn9gzZpTivr+TOfGmD6kPTyiAFFwSqq8GBETgyHbt0Or96ZcbuVFwWSCpqR9uZUXyePBo/v2QRcZCcFikV1NMiImBo/s2OEvOy2nmmRETAwe3rYNushIAJBdTZLcbm/fo6LgNJlkVcj07Ubodjoh2myyK2RGxMRgyLZt0EZEXMuZxAqZETExeGjLFuijo0FEsqt+EhEe3bcP2hIv5VT91Oh0eHTfPmi0WricTtlVPwHvicnjcvnHm9Sqn7qoKDy0ZQsiYmKCqmQKjcarW6+Hy26XXcn00X37vDkXRdmVTPU1anhzVqMGyOORVZ3VI4r+k3kw1Vm1er237xrNtZxJPEfoIiPx6L59ILcbHrdbdnVWXWQkHt669VrOZFSc1er1GPLTT97Xg6g46xFF73fLYoGn5POkniP0NWpg2J49oJIdxOVW0dVGRGDItm1BVdGFRoNHdu5ERExMUFV0dVFR/pyRxyOrim6okX0lJCIiAlqtN6x+/fq4cuUKACAhIQHp6emh7V0ICVUV3XWDBqH47FlodTpZFTLPp+dh7yUjNADaN6yBxldPoHNSLbSrF4kmWafROakW2tbWIzH3HDon1cIdCcBNhRfROakW2sS40cyYjq7NauPFukZ0mDcRWq1GVuVFrU6H3z74AMfmzi2nSUrlxRXJyUgo8VJu5cVlt9+OOm3aIGPHjqCq6Gp1OpxeuhS/vP225Dz5NGl1Omx59llk7NghKU9lNX1RuzbqtGkD49mzYa+iq9XpsHfKFJxZtkxynnyatDodVnXvDltOTlBVdL/p0QN12rTBpe+/l11F95e330adNm2w67XXwl5F13j2LNYNGACtThdUFd2tzz+POm3a4OCHH8quontm2TLUadMG6wYNCqqKrstmw6ru3eGy2cJeRffghx+iTps22Pr887Kr6OYdOoQ6bdpgYVJSUFV08w4dwoYhQ6DV6WRX0T344Yc4NmeO97sS5iq6LpsNkbVq4YvatSXnKVDTmWXLsHfKFGh1OtlVdLc+/zyu/vQTtDpdUFV0jWfPok6bNviidm32qugOGDCAli1bRkREo0aNoq5du9LSpUtp0KBB1LVr15A8N1yVKK2ia87MpFkAOYxGWRUyZ205Q0kT0qjnY++RvagoqCq6DqORZgFkzsz09ldG5UVfrDU3t5ymqq6ia7p6lWYBZCsoCKqKrq/vlpwcyXnyafLF2koqssqtomtKT/fGFxaGvYquP2clVTrlVNH1xdqLioKqomvOyPC2nZ8vu4quJSfHm6/s7LBX0bUVFvq/n8FU0TVnZfm/J3Kr6Frz8vzfz2Cq6NqLi705Ky4OexVda26ut+9ZWbKr6NoKCmgWQKb09KCq6Pri/TmTcY7w9dthNIa9iq4vX6aSPafkVtH1jRdfRV455wjfOHUYjUFV0fV9T0zp6apX0ZU9CTlw4ABt376diIhycnJo0KBBFBcXRx07dqQjR46EpFNVidLNynz/MXncbukxHg/1+nA7JU1Io2VbfpcVq7TtUMQSKdvUR2nbaupWEq90AylWdfOxxscaK23zsSY/PtSTENn3hHTu3Nl/XL9+fWzatEnuR7CNRgNDfDyg0Vz/vSUcvFyEywU21DDocG/7RFmxStsOSaxSlLatpm5WfWPZcyWwrJtV31j2XAks61bTtzIEtVnZX5nAtTOprD6UAQAYdFsdLK5XW9EGM3LbDkWsUpS2raZuVn1j2XMlsKybVd9Y9lwJLOtW07eyBLVtO8so3SeEAp400EiYRTpEN7r8ayvMDheWj+qGTvUNkmOVth2qWEDZ8/RK21ZTt5J4pXsQsKqbjzU+1lhpm481+fGq7xPyl4cIgskESJy7bT2VA7PDhSY1o9GtWS1ZsUrbDlmsUpS2raZuVn1j2XMlsKybVd9Y9lwJLOtW07cy8EmITASLBQsSEyWXQF598CoA4OEOTeCyWWXFKm07VLFKUdq2mrpZ9Y1lz5XAsm5WfWPZcyWwrFtN38rCl2OqkFyzAykztsPtIWx7vTduqRdbpe1VJXx7Y/lwz4KD+yYf7llwcN/kE+rlGNlPx3z22WcVvq7RaBAVFYUWLVqgV69e0JXsbnmj4XG7UXT6NGq1agXtdTSuP5IJt4fQ4aaauKVerKxYpW2HMlYpLOtm1TeWPVcCy7pZ9Y1lz5XAsm41fSuH3Gd6mzVrRjExMaTRaKh27dpUu3Zt0mg0FBMTQw0aNCCNRkO33HILXblyJejnhqsSpfuEOIxG+jwuzr+By59xz6xdlDQhjRbvuyQ7VmnboYwlUvY8Pcu6lcQr3buBVd18rPGxxkrbfKzJjw/1PiGyl2O+/vprfPnll5g/fz5uueUWAMC5c+fwwgsv4O9//zvuvPNOPP7442jYsCG+/fbb0M6YQkC4lmNOZppw32e7YdBpsf+tu1GzhqHK2goH/LKlfLhnwcF9kw/3LDi4b/JR/emYKVOm4D//+Y9/AgIALVq0wMcff4xJkyahadOm+PDDD7Fnzx7FnauOeFwuZO3b5y+uVRlrDnlvSL27dX3/BERqrNK2Qx2rFJZ1s+oby54rgWXdrPrGsudKYFm3mr6VRfYkJCsrC64KOu5yuZCdnQ0AaNy4MczVYBOUPyOwiq7/2G73VjAEINps146tVrgFAQBgz8/HhqFD4bLbIVgs/iQKZrP/2FpsxLoj3g3KBreuDfJ4QESw5eRgw9ChEK1Wfwllj9t97djl8m8e43G5/Hcuu0URotUKl92ODUOHwp6f7+1vSXVW37GvwmFFmlx2OzY88gicxcXlNIlWK9wl1SQr01S2iq5Pk9NkAhGBPJ5KNdlyc7Fx2DAIZnM5TQBKVZytSJNPt6OoSHKefJp8un2+BmpymkzwlFTArEyTLSfH23eLRXKeympyy8hToCZ/zoxGyXnyafLFilar5DwFarLn5WHjsGFwmkyS8+TT5CgqwsZhw+AoLJScp7KaylbRvV6efDoEiwUbHnkELrtddp5cTifsBQVe3cXFkvPk0+E0GrFx2DDY8/Ml5ylQk2izeXNms0nOk09T2Sq6UvIUqMlZXOzte0GBrDwJZjMEsxkbhw2DLSdHcp4CNQlmc+mcyThHOIuL/edjuefyclV0JebJp0m02bBh6FDYcnIk5ylQk9No9OuWcy4HAHtBgV+33HO502SCYLH4cybnXF4Vm5vJnoT07dsXL7zwAg4fPux/7fDhw3jppZfQr18/AMCxY8dw8803h66XISBUVXTTHn4YvWfNgiEurtIqhdPuegD5FgF1Ygw41fVWf5XCr5o2xTOnTvl3qwPkVV40xMWh+/Tp/mqLciovGuLi0OjOO6/pCGMV3ZVdu2Lk1avI2b8/qCq6hrg4tHzsMX9u5FTRNcTFIbJWLeTs319Ok5TqrF81bYqRV6/CmpER9iq6hrg41LnjDpxfu1ZynnyaDHFxsGZl+f+TkFtFd03//hh59SqulhxLyZNP028zZmDk1av+Yyl5Kqsp2Cq61owMiBYLDHFxQVXR3TFmDEZevYrfZ8+WXUX3/Nq1GHn1KtIefjioKroAYM3KAoCwV9H9ffZsjLx6FTvGjJFdRbfo9GmMvHrVfywlT4Gaik6fhkarhSEuTnYV3d9nz0aze++FIS4u7FV0AeCxX3/FVwE65Jwjzq9dizp33AFDXJzsKro7xoxBx9dfhyEuLqgqutaMDIy8ehVfNW3KXhXdrKws6t+/P2k0GjIYDGQwGEir1dKAAQMoOzubiIi2b99OmzdvVnzDSlWgtIquo7iYLqSl+SsjVlSl8MVFv1DShDR6Z/3xUpUX7QUFdPGHH8jldAZVRdctinTh++/JUVzs7a+MyotuUaRz69b5KziGs4quvbCQLm3aRKLdHlQVXbco0vn16/2xcqroukWRzq1d6/dDbhVde0GBt+8lVW2l5MmnSWkVXX/OSmLlVNF1iyKdXb2aXE5nUFV07UVFdGnTJhJsNtlVdJ1mM13atImcJlPYq+iKDgedXb2a3KIYVBVdh9Ho1W2xyK6iK1itdGnTJnIUFwdVRdclCN6cCULYq+gKFou37yUVXaXkyadJtNvp0qZNZC8oCKqKrmi309k1a67lTMY5QrBY6Px335FbFMNeRdclCHRx40ayl4xTuVV0BauVzq1b5+27zCq6DqORzq9fT25RDKqKruhw+HPGXBVdH6dOnaLvvvuOvvvuOzp9+nRIOhMOlD4d4zSbaXFysn9QlaXYJtCtb22kpAlpdOxqsaxYpW1XVSyRsrvIWdatJF7pEwus6uZjjY81VtrmY01+vOpPx/z888+46667Qno1JpxU9dMxX++/gklrjqFlg1hsfq1XUPv6V0f4XeTy4Z4FB/dNPtyz4OC+yUf1p2P69euHm2++GZMnT8bJkycVd4A13KKIs99847/5pyy+bdof6di03ATkerFK266qWKWwrJtV31j2XAks62bVN5Y9VwLLutX0rSyyJyGZmZl4/fXXsXPnTtx+++1o3749PvroI1y9erUq+lft8AgCDs2cCU/J3ciBXC6w4rfLRdBqgIc6NJEVq7TtqoxVCsu6WfWNZc+VwLJuVn1j2XMlsKxbTd/Koqh2zMWLF7F8+XJ8/fXXOH36NHr16oXt27eHsn8hpyqXY2Zu+QOfbTuLXi3rYfHzXUP62WrDL1vKh3sWHNw3+XDPgoP7Jh/Vl2MCufnmmzFx4kS8//77uOOOO7Bz507FHaruuAUBx+fP9z+X7cPjIf8GZY90LH8V5M9ilbZd1bFKYVk3q76x7LkSWNbNqm8se64ElnWr6VtZgp6E7NmzB6NHj0ajRo3w5JNP4vbbb8eGDRtC2bdqiadkLc1TZi3twKVCXC2yIzZSj4HJDWXFKm27qmOVwrJuVn1j2XMlsKybVd9Y9lwJLOtW07eyyF6OmTRpElasWIHMzEwMGDAATz31FB588EHUqFGjqvoYUqpqOWbCt0ex8rd0PNq5KT4c2i5kn1td4Jct5cM9Cw7um3y4Z8HBfZOP6ssxu3btwhtvvIGMjAykpaXhiSeeUDwBSU1NRbNmzRAVFYVu3bphf8nultdjxYoV0Gg0eOihhxS1LweX04lDM2f6t88FALvgxoZj3p0OH+lY+cSmolilbYcjViks62bVN5Y9VwLLuln1jWXPlcCybjV9K4vsSYhvGaZu3boh6cDKlSsxfvx4TJs2DYcOHUK7du0waNAg5Obm/mncpUuX8I9//AM9e/YMST+kQm43svbtA5XUEwCAH09mw+J0oWmtaHRpVltWrNK2wxGrFJZ1s+oby54rgWXdrPrGsudKYFm3mr6VJeinY06ePIkrV65AKHNjy+DBg2V9Trdu3dClSxfMnj0bAODxeJCYmIixY8di4sSJFca43W706tULzz//PHbv3o3i4mKsK9kv/3pUxXLM8AX7seuPPLxy960YP6BlSD6zusEvW8qHexYc3Df5cM+Cg/smn1Avx+iv/5bSXLhwAQ8//DCOHTsGjUYD3xzGtzGXW8bMShAEHDx4EJMmTfK/ptVq0b9/f+zbt6/SuHfffRf169fHyJEjsXv37j9tw+l0whlwyclUUhHQZjbDUnIsB5fTicMzZ6LD+PHQR0Yi1+zEz2fzAAD33Jrwp59ZNlZp2+GKBQBriS5rCDwLZ7yabSvxTGnbLHvOxxofa+Fqm481+fG2EFfSlX0l5IEHHoBOp8P8+fNx8803Y//+/SgoKMDrr7+Ojz/+WNbySGZmJpo0aYK9e/ciJSXF//qbb76JnTt34tdffy0X8/PPP+Pxxx/HkSNHULduXTz77LN/eiXknXfewfTp08u9fgcAneSeVo6j6xDY+z4P3dUTiF82IQSfyOFwOBxO9cQN4Big3pWQffv2Yfv27ahbty60Wi20Wi3uuusuzJgxA6+88goOHz6suFOVYTab8cwzz2DevHmS70mZNGkSxo8f7/+3yWRCYmIi1pw8iYZNKt7PQypEhIfnHcK5fBum/N+DGPb5i4o+rzpjNZlwT2IiNqWnI4ZftpQE9yw4uG/y4Z4FB/dNPtkZGbg1OTl0Hyi34l3NmjXpwoULRETUvHlz2r59OxERnTt3jqKjo2V9ltPpJJ1OR2vXri31+vDhw2nw4MHl3n/48GECQDqdzv9Ho9GQRqMhnU5H586du26bSqvoinY77Rw3jkS7nY5dLaakCWl061sbqdgmyIpV2nY4Y4mUVZtkWbeSeKWVTVnVzccaH2ustM3Hmvz4UFfRlf10zO23347ff/8dgPem0g8//BB79uzBu+++i+bNm8v6LIPBgE6dOmHbtm3+1zweD7Zt21ZqecZHq1atcOzYMRw5csT/Z/Dgwejbty+OHDmCxMREuXIUsbpkh9QByQ2QEB0R1rY5HA6Hw2EeubOWTZs20erVq4mI6OzZs3TbbbeRRqOhunXr0rZt22TPglasWEGRkZG0aNEiOnnyJP3973+nmjVrUnZ2NhERPfPMMzRx4sRK40eMGEEPPvig5PaUXgnxIbjc1PHdHylpQhptP5Wj6LNYQOlvWn9FuGfBwX2TD/csOLhv8lH9SsigQYMwZMgQAECLFi1w+vRp5OfnIzc3F/369ZM9CXrsscfw8ccfY+rUqWjfvj2OHDmCTZs2oUGDBgCAK1euICsrS/bnVhUuux1bR43C9mMZKLAKqBsbiZ63Srs/xRfrstsVtR1MvNK2lcCyblZ9Y9lzJbCsm1XfWPZcCSzrVtO3ssi+MbUiateufIMuKYwZMwZjxoyp8Gc7duz409hFixYpals2Wi1imzbFwqPZAICH2jeGXidxLlcSC22QJXuUxCttWwks62bVN5Y9VwLLuln1jWXPlcCybjV9K0PQm5WxSig2Kyu2Cej6r20Q3B5sfKUnkhvf+HdV80195MM9Cw7um3y4Z8HBfZOP6rVj/uqINhtmjH0XgtuD1o3iZU1ARJsNG4YNg2izBd12sPFK21YCy7pZ9Y1lz5XAsm5WfWPZcyWwrFtN38rCJyEy0eh0ONyoPQDgkY7y9hnR6HRolJICjS64bdKUxCttWwks62bVN5Y9VwLLuln1jWXPlcCybjV9K9cXvhwjj/N5Ftz9yU7otBrsm9QP9eOiqqCX1Q9+2VI+3LPg4L7Jh3sWHNw3+fDlGJX59teLAIC7mteSPQERrVasHTQIotUaVNtK4pW2rQSWdbPqG8ueK4Fl3az6xrLnSmBZt5q+lSUkT8ewyE9/FKBOsfxLUeuO5QKQvxQDANqICNw6bBi0EcFtbKYkXmnbSmBZN6u+sey5EljWzapvLHuuBJZ1q+lbWf6yyzGJr62CNrJGUJ8RF6XHgbf6Q+u0Qx8VBa1eD8Fshj46Glq9Hk6TCRExMdDqdHCaTDDExgIaDQSzGYa4OIAIgsWCyPh4eNxuiFar99jlgstuhyEuznvscMAQGwu3KMIjCIiIiYFbEOARRUTExMDldILcbkTUqAGX0wl4PNBHR8PlcAAA9FFR3ufAtVroIyMh2mzQ6HTeY6sV2ogI6AwG77HBAF1EBASLpUJNhVevon9iInYZjYgAbghNVZ0nU0EB+jVujB25uagRE3NDaApHnmw2G/omJGBbQQHia9e+ITRVdZ5MBQW4u25d/GQ0Ijoq6obQFI482R0O9K5bF9szMpBQv/4Noamq85RvNPLlmGBITU1FcnIyunTpAgC42ZmPzkm1cKunGLd6itE5qRZaiAW4TWNG56RaaG7PQasIGzon1cLNlkwkRwnonFQLzYovo//P/4NOcGBlt25IL9lyfknr1sg5cAAAsKBpUxSdPg0AmJuQAEtmJgSzGXMTErCia1cUnzuHuQkJAICi06exoOTelJwDB7CkdWsAQPq2bVjZrRsA4MK6dVjTvz9EqxWLW7fG9w8+CAA4mpqKH0eMAAD8NmMGdowdCwDYO3ky9k6eDADYMXYsfpsxA6LViq8SE3H4P/8BAKQNGYJTixcDANb0748LJVWIK9O0IjkZCSVeltUkmM2wZGZWqmlxq1ZYmZKCixs2lNMEAKcWL0ZayQZ4FWkSrVYsvPlm/PzGG6U0AcCPI0bgaGpqpZpEqxXz6tfHxQ0bZOUpUNPKlBTkHTokOU8+TduefhoAcHLePMl5CtQkWq2Y36QJjs+bJzlPPk2i1Yq5CQkoPndOcp4CNa3o0gUrU1Lwx4oVkvPk0/TzG29gZUoKtr/0kuQ8ldX0MIC8Q4dk5QklMV/Urg3RapWcp0BNm596CitTUvDr9OmS8+TTdHzePKxMScHqfv0k5ylQky07G3MTEmDLzpacJ5+my2lpGAjIylOgpl+nT8fKlBRsfuopWXla0ro1MnbtwsqUFHwlI0+BmjJ27cIXdetCtFol58mn6dfp07EgKQmi1So5T4GaLqelAQDW33237HO5LTsbX3fuHNS5HACOz5uH+U2aQLRaZZ3LAWDzU09h8W23QbRaZZ/LFzRtirxDh7AyJUX2udynKaSEZN9VhvBt23757Fki8hby8RXxEW02Eh0OIiISrNZrxxYLuZxOIiKyFxXR6eXLySUI5DSbyS2KRETkNJn8xw6jkdwul//Y43aTx+MhW34+nVm5kkSHgxwlW966Xa5rx6JITpPp2rHZTERELkHw9kEQ6PTy5WQvKvL21+EgwWr1H4s2W6WaXIJAp5Ys8X9moCbfZxNRpZoK0tOpQ8n2xoGaHEYjeTwe8rjdlWqyFRTQH6tWkWCzldNERORyOv3HFWlyCQKdWrqUHCXeSMmTT5NLEOjk4sUklHgjJU+Bmmz5+d6+2+2S8+TTVJiZSe0BKs7NlZynQE2+vjtLPlNKnnyaXIJAJxYtItHhkJynQE22wkL6Y9UqclqtkvPk0+QwmeiPVavIYTRKzlOgJrPRSJ0BMhYUSM6TT4dgt9OJRYvIJQiS8xSoyV5c7NVtNkvOk0+H02KhP1atIntRkeQ8BWoSnU5vzpxOyXnyaTLm51Pnku+n1DwFanKazd6+FxdLzpNPk2Cz0R+rVpEtP19yngI1CTYbnfzf/67lTMY5wmk206mlS8klCLLP5YLFQsb8fGoPUGFGhqxzucNoJNHppDMrVpAtP19yngI1OS0WOrl4sbfvMs7lRET24mI6tWzZtf8bZJzLHUYjCXa7P2dyzuVOkynk27b/ZZdjlGxW9leE30UuH+5ZcHDf5MM9Cw7um3z40zEqI1gsWNKmDQSLJayxaretBJZ1s+oby54rgWXdrPrGsudKYFm3mr6VIyTXUxhCaRVdtyjSpU2b/Je2whWrdttKqk2yrFtJvNIKnazq5mONjzVW2uZjTX48X45RCF+OCQ5+2VI+3LPg4L7Jh3sWHNw3+fDlGJURzGZ81bQpBLM5rLFqt60ElnWz6hvLniuBZd2s+say50pgWbeavpUjJNdTGCIUyzGZe/cGfQkt2Fi121Z62ZJV3UriQ3GJnEXdfKzxscZK23ys8eWYsMOXY4KDX7aUD/csOLhv8uGeBQf3TT58OUZlnCYT5sTHw2kyhTVW7baVwLJuVn1j2XMlsKybVd9Y9lwJLOtW07dyhOR6CkMoXo5xuSj/+HH/BjbhilW7bUWXLRnWrSRe8SVyRnXzscbHGitt87EmP54vxyiEL8cEB79sKR/uWXBw3+TDPQsO7pt8+HKMyjhNJnyq0QR9CS3YWLXbVgLLuln1jWXPlcCyblZ9Y9lzJbCsW03fyvKXnYT4qhO6HI5rx3a7t4IhANFmu3ZstcItCAAAjUaDZy9cgCE2FoLFAo/LBcD7yJPv2GkyweN2+4/J4wERgTwePHflCiJq1PAn3+N2Xzt2ufyPTHlcLv9udm5RhGi1whAbixHnz0Oj0Xj763RCtNn8xy67vVJNhthYDP/jD3/p5kBNotUKtyh6dVSiSTCZoCnxLlCT02Tya6tME4jwfHo69FFR5TQBgFsQ/McVaTLExmL42bPQ6vWS8+TTZIiNxTOnT0MfFSU5T4GayOPx9j06WnKeympyy8hToCZDbCyeOXMGOoNBcp58mgyxsXj65ElE1KghOU+BmgDg+fR06EqqdErJk0+TVq/H8+np0Op0kvNUVpM+oB9S8uTToY+OxtMnT8IQGys7Ty6nExqt1tv3iAjJefLp0BkMeD49HRqNRnKeAjVFxMR4cxYTIzlPPk0eUYT32yE9T4GatBER3r5rtbLyJJjN0EdF4fn0dJDHIzlPgZr0UVF45tSpazmTcY7QRkRg+B9/wBAbK/tcLlqt8JRoEmWey50mbyXa5y5fBnk8kvMUqElnMOCZM2e8fZd5jtBotRhx7hwMsbGyz+VOkwn66Gh/zuScy6vikd6/zCSkbBXdA1OmAJBeIdNXpXDtwIHI2LUL0GhkV9H9olYtaDQaWLKygqu8qNHg0oYN2DB0KAB5VXSh0eDnN97A0c8/L6epqqvoLmnTBob4eKRv3x5UFV1oNDgyaxb2vvWW5Dz5NWk0SHvoIaRv3y45T4GavqhVC4b4eBSdORP2KrrQaPDTSy/h1JIlkvPk16TRYGlyMixZWUFV0V2VkgJDfDwufPed7Cq6e996C4b4eOx45ZWwV9EtOnPGmw+NJqgqulueew6G+Hj89v77sqvonlqyBIb4eKwdODCoKrqCxYKlyckQLJawV9H97f33YYiPx5bnnpNdRTfnt99giI/HgptuCqqKbs5vv2HN3XcDGo3sKrq/vf8+9r/3HqDRhL2KrmCxQLRa8UWtWpLzVErTkiX46aWXAI1GdhXdLc89hz9WrvSe34Koolt05gwM8fH4olYtXkU33CitomvOzKRZADmMRtlVdE3p6TQLIHtRUVBVdB1GI80CyJyZ6e2vjMqLvlhrbm45TVVdRdd09SrNAshWUBBUFV1f3y05OZLz5NPki7WVVGSVkqdATb6c2QoLw15F15+zvDzJefJp8sXai4qCqqJrzsjwtp2fL7uKriUnx5uv7OywV9G1FRb6v59S8xSoyZyV5f+eyK2ia83L838/g6miay8u9uasuDjsVXStubnevmdlya6iaysooFkAmdLTg6qi64v350zGOcLXb4fRGPYqur58mUoecpBbRdc3XnzVpuWcI3zj1GE0BlVF1/c9MaWn8yq64UbpjalEBMFshiEuzr8sEo5YtdtWcgMXy7qVxCu96Y1V3Xys8bHGStt8rMmP5zemqg0RBJMJCGbupiRW7baVwLJuVn1j2XMlsKybVd9Y9lwJLOtW07cy8EmITASLBQsSE4MuvxxsrNptK4Fl3az6xrLnSmBZN6u+sey5EljWraZvZeHLMRxJ8Ofp5cM9Cw7um3y4Z8HBfZMPX45RGY/bjYITJ/yPbYUrVu22lcCyblZ9Y9lzJbCsm1XfWPZcCSzrVtO3svBJiExEqxWrUlL8z3qHK1bttpXAsm5WfWPZcyWwrJtV31j2XAks61bTt7Lw5RiOJPhlS/lwz4KD+yYf7llwcN/kw5djVMbjciFr3z7/7nPhilW7bSWwrJtV31j2XAks62bVN5Y9VwLLutX0rSx8EiITl92OjcOG+bfVDVes2m0rgWXdrPrGsudKYFk3q76x7LkSWNatpm9l4csxHEnwy5by4Z4FB/dNPtyz4OC+yYcvx6iMx+XC5c2bg76EFmys2m0rgWXdrPrGsudKYFk3q76x7LkSWNatpm9l+ctOQoKtomsvKMDOcePgcjhkV9G15eZi57hxEG22oKrouhwO7Bw3DvaCAm9/ZVRedDkc2Pnaa3AajeU0VXUVXVteHnaNHw/BYgmqiq6v747iYsl58mnyxfralVtF15ab6+271Rr2Krr+nJW0K6eKrsvhwM5XX4VoswVVRdeen49d48fDaTbLrqLrKC7GrvHj4SgqCnsVXcFqxc5XX4XL4Qiqiq69sNCr22iUXUXXaTJh1/jxsBcUBFVFV7TbvTmz28NeRddpNHr7Xlgou4quYLFg1/jxsOXmBlVFV7BYSudMxjnCaTRi52uv+fWEs4quaLdj57hxsOXmSs5ToCanyXSt7zLPEfbCQn9sMFV0BavVnzO1q+j+ZQrYzZ49m1q3bk0tW7YkAPTtY48REdHOceNo57hxRES0ZeRI2jdtGhERpQ0dSgc/+YSIiNYMHEjH5s0jIqIV3bvTH6tWERHR4uRkurRpExERzW/ShDL37iUios/j4ij/+HEiIn+RIF9BMYfR6C+KRkSUf/w4fR4XR0REmXv30vwmTYiI6NKmTbQ4OZmIiP5YtYpWdO9ORETH5s2jNQMHEhHRwU8+obShQ4mIaN+0abRl5Mgq05QaF0d9Sgpk3SiaqjpP3/TrR+0B2vuvf90wmsKRJ7PRSP8C6NyWLTeMpqrO09FFi2hyyffzRtEUjjwdXbSI2gO0qFWrG0ZTVecp1AXs/jKTEB9Kq+jai4ro9PLl5BIE2VV0bfn5dGblSn+FVCJ5lRddgkCnly8ne1GRt78yKi+6BIFOLVni/8xwVtG1FRTQH6tWkWCzBVVF1yUIdGrpUnKUeCOniq5LEOjk4sUklHgjt4quLT/f23e7PexVdH19d5Z8ppwqui5BoBOLFpHocARVRddWWEh/rFpFTqtVdhVdh8lEf6xa5a8OKiVPgZqUVNEV7HY6sWgRuQQhqCq69uJir26zWXYVXafFQn+sWkX2oqKgquiKTqc3Z05n2KvoOs1mb9+Li2VX0RVsNvpj1Sqy5ecHVUVXsNno5P/+dy1nMs4RTrOZTi1dSi5BCHsVXdHppDMrVpAtP19yngI1OS0WOrl4sbfvMqvo2ouL6dSyZdf+b5BZRVew2/05U7uK7l92EpJRUn5ZLoLFQiu6d/cPpHDFqt222Wik9iUnuXC3zarnSjxT2jbLnvOxxsdauNrmY01+fKgnIfzpGI4k+F3k8uGeBQf3TT7cs+DgvsmHPx2jMm5BwPH58/03AoUrVu22lcCyblZ9Y9lzJbCsm1XfWPZcCSzrVtO3svBJiEw8ooiz33zjv6s6XLFqt60ElnWz6hvLniuBZd2s+say50pgWbeavpWFL8dwJMEvW8qHexYc3Df5cM+Cg/smH74cozIupxOHZs70P68drli121YCy7pZ9Y1lz5XAsm5WfWPZcyWwrFtN38rCJyEyIbcbWfv2gUo2sAlXrNptK4Fl3az6xrLnSmBZN6u+sey5EljWraZvZeHLMRxJ8MuW8uGeBQf3TT7cs+DgvsnnhlyOSU1NRbNmzRAVFYVu3bph//79lb533rx56NmzJ2rVqoVatWqhf//+f/r+UONyOvHLO+8EfQkt2Fi121YCy7pZ9Y1lz5XAsm5WfWPZcyWwrFtN38qi+iRk5cqVGD9+PKZNm4ZDhw6hXbt2GDRoEHJL9uMvy44dO/DEE0/gp59+wr59+5CYmIiBAwciIyMjPB32eGC5ehXweMIbq3bbSmBZN6u+sey5EljWzapvLHuuBJZ1q+lbGVRfjunWrRu6dOmC2bNnAwA8Hg8SExMxduxYTJw48brxbrcbtWrVwuzZszF8+PDrvp8vxwQHv2wpH+5ZcHDf5MM9Cw7um3xCvRyjv/5bqg5BEHDw4EFMmjTJ/5pWq0X//v2xb98+SZ9hs9kgiiJq165d4c+dTiecAZecTCUVAW1mMywlx3JwORzYP306uk6bBn1UVNhi1W7bWuKVNcyeKY1Xs20lniltm2XP+VjjYy1cbfOxJj/eFuJKuqpeCcnMzESTJk2wd+9epKSk+F9/8803sXPnTvz666/X/YzRo0dj8+bNOHHiBKIqMPOdd97B9OnTy71+BwCdot5zOBwOh/PXwg3gGHBjXAlRyvvvv48VK1Zgx44dFU5AAGDSpEkYP368/98mkwmJiYlYc/IkGjZpEq6uMo/VZMI9iYnYlJ6OGH7ZUhLcs+DgvsmHexYc3Df5ZGdk4Nbk5NB9YEjK4AWJ0+kknU5Ha9euLfX68OHDafDgwX8a+9FHH1FCQgIdOHBAVptKq+iKNhttGTnSX2o5XLFqt62k2iTLupXEK61syqpuPtb4WGOlbT7W5MeHuoquqk/HGAwGdOrUCdu2bfO/5vF4sG3btlLLM2X58MMP8d5772HTpk3o3LlzOLp6Da0WsU2bAtogrFMSq3bbSmBZN6u+sey5EljWzapvLHuuBJZ1q+lbGVR/OmblypUYMWIEvvjiC3Tt2hWzZs3CqlWrcPr0aTRo0ADDhw9HkyZNMGPGDADABx98gKlTp2L58uW48847/Z8TGxuL2NjY67bHn44JDn4XuXy4Z8HBfZMP9yw4uG/yueE2K3vsscfw8ccfY+rUqWjfvj2OHDmCTZs2oUGDBgCAK1euICsry//+OXPmQBAEDB06FI0aNfL/+fjjj8PSX9Fmw4ZhwyDabGGNVbttJbCsm1XfWPZcCSzrZtU3lj1XAsu61fStLNXixtQxY8ZgzJgxFf5sx44dpf596dKlqu/Qn6DR6dAoJQUanfxna5TEqt22EljWzapvLHuuBJZ1s+oby54rgWXdavpWri9qL8eEG74cExz8sqV8uGfBwX2TD/csOLhv8rnhlmNYQ7RasXbQIIhWa1hj1W5bCSzrZtU3lj1XAsu6WfWNZc+VwLJuNX0rC5+EyEQbEYFbhw2DNiIirLFqt60ElnWz6hvLniuBZd2s+say50pgWbeavpWFL8dwJMEvW8qHexYc3Df5cM+Cg/smH74cozKi1YqVKSlBX0ILNlbttpXAsm5WfWPZcyWwrJtV31j2XAks61bTt7LwSYhMtAYDOo4fD63BENZYtdtWAsu6WfWNZc+VwLJuVn1j2XMlsKxbTd/KEZJ9VxnCt2375bNniYhItNtJtNu9xzYbiQ4HEREJVuu1Y4uFXE7ntWNBICIip9lMblH0HptM/mOH0Uhul8t/7HG7yePxeI89HvK43eQo2fLW7XJdOxZFcppM147NZiIicgkCCRaL99jp9B+LDgcJVqv/2LcFb1VoKkhPpw4l2xvfKJqqOk+FmZnUHqDi3NwbRlM48mQ2GqkzQMaCghtGU1XnyZifT51Lvp83iqZw5MmYn0/tASrMyLhhNFV1nm6obdvDSWpqKpKTk9GlSxcAwIEpUwAAeydPxt7JkwEAO8aOxW8lO7P+OGIEjqamAgDShgzBqcWLAQCr+/bFoubNIVgsWNmtG9JLtpxf0ro1cg4cAAAsaNoURadPAwDmJiTAkpkJwWzG3IQELGndGkVnz2JuQgIAoOj0aSwouTcl58ABLGndGgCQvm0bVnbrBgC4sG4d1vTvD8Hy/+2deVwT19rHf0kggCxRQAQEwRUQBfetrdiK+2vdrrWKVVurrReXul1rrxW1i1Ztr636vnbV1qUu16KWXvVaFLWCqAilKiogikoAoWxhy/a8f5CMCQTIJEhMPd/PJx8Ok3nmPMuZmSdnzpkjw3f+/vh53DgAQOr27fjvzJkAgCvr1yNuwYJ6bZLLZPja0xPJn31Wx6afwsNx58gRAKjXpv1du0Ki8WVtm+RlZZDl5NRr0w+BgdgdHIw7MTF1bAKAtB9+QMzEifXaJJfJ8E3btji/bJnRcdLaJJfJ8JW7O+7ExPCKk65Nu4ODkX/1qtFx0toUO306AODG118bHSddm+QyGb5q0wZ/fPWV0XHS2iSXybBDIkFRerrRcdK1aX/fvtgdHIzb+/cbHSetTeeXLcPu4GDEvv220XGqbdMEAI+uXuUVJwDIv3oVO1q1glwmMzpOujadiIjA7uBgJK5da3SctDb98dVX2B0cjMMvvmh0nHRtKpdKsUMiQblUanSctDbdi4nBcIBXnHRtSly7FruDg3EiIoJXnHYHBeHB2bPYHRyMb3nESdemB2fPYoerK+QymdFx0tqUuHYtvvH2hlwm430t/yk8HPc014VjQ4fyvpaXS6X4ITDQpGs5APzx1Vf4qk0byGUyXtdyADgREYHv/Pwgl8l4X8u/8/FB/tWr2B0czPtarrWpSWmSVMaKMLcnpKq4mO7ExHDZLZ9Ms7KwkLKOHydldbVJ2bNKoaA7P/9MVcXFNfryyJ5VCgVlHDnCZd7N2RNS+eefdPfECVJUVpr0i0ClUFDmsWOcLJ9fBCqFgjKiozl/8P1FUFlYWKN7VVWz94RwMdPI8vmVo1IoKP3wYVJWV5v0y62yqIjunjhB8ooK3r/cqsvK6O6JE1RdWtrsPSGKqipKP3yYVAqFSb9Gq0pKauyWyXj/GpWXl9PdEyeoqrjYpF+jSrm8JmZyebP3hMhlshrdS0p4/8JWVFbS3RMnqLKw0KRf2IrKSkr/6afHMeNxjZDLZJR59CipFIpm7wlRyuWU9Z//UKWmnfLtCZGXl1PGkSM1uvPsCakqKaHMY8dIpVCY1BOiqKriYmbpnhA2O4ZhFGwUOX+Yz0yD+Y0/zGemwfzGHzY7xsLIy8rwrY8P5GVlzSpr6brNwZrttla/WbPPzcGa7bZWv1mzz83Bmu22pN/q0CT9KVaE9nHMw/v3TZJXKRSUEx/PdW01l6yl6y4rKaEemu7e5q7bWn1ujs/Mrduafc7aGmtrzVU3a2v85dnjGDNhj2NMg3Vb8of5zDSY3/jDfGYazG/8YY9jLEx1aSn+z8UF1aWlzSpr6brNwZrttla/WbPPzcGa7bZWv1mzz83Bmu22pN/q0CT9KVaE2Y9jlEoquHaNGzHdXLKWrtusbksrttscebO7yK3UbtbWWFuzlrpZW+Mvzx7HmAl7HGMarNuSP8xnpsH8xh/mM9NgfuNPUz+OsWkCnf5yEBGUSiVUKlWd7+QyGfb36YNXr1yB2MmJ13HNkbV03dVyOTz9/FAtl8OmqqpZ67ZWn5vjM3Prtmafs7bG2lpz1f0stTWRSAQbGxsIBAJUl5Zih0SCt0tKYGfh5Iv1hNRCLpdDKpWioqLC8AGIoFapIBSJAIGAX+XmyFq4brVajbz799HG1xdCIc+hRFZstznyZvnMzLqt2eesrbG21lx1P2ttrUWLFvDy8oKtjQ1kOTlw8vaGgKfdrCfkCaJWq5GVlQWRSARvb2+IxWIIagWYiEBqNQRCYZ3vGsMcWUvXrVKpQJWV8Pf3h0gkata6rdXn5vjM3Lqt2eesrbG21lx1PyttjYggl8vx6NEjZGVloVOnThC7uJiWPDUxLAnRQS6XQ61Ww9fXFy1atDC4j1qlwqPkZLTu2bMmC+WBObKWrlulUkEIwN7envfJas12myNvjs/Mrduafc7aGmtrzVX3s9TWHBwcYGtri3v37qG8qAg7W7d+Kh7HPLNTdJWa53/Kqiq9MhFBKBRCrVKB1GoA0CsDgHuPHhBo99E8zWqsTEQAEVrryAI1GWqjZbUaapUKAqEQ7qGhnB7a7dqyVkdDZU5Wk/nWZ199dpDO+Bhdm2qXDdkBAK179oRAIKhjU2NlQ7rr2tegHVrZkBDu14IxcaoTs549jYtZbd0bsKmhcoO6NxInbZmTFQqNjpM5MdO1AwIBWvfs+fh/I+JU2w6NIkbHSauLIbsbi5NuWWs3BAKj46QtC+qz28hrhFG611OGjt+MjZNZMdPRnbNbe84YESe9mAkEhu024hoBgQDuoaE1skbGSbes9RvxvJZrr8ete/R4fAwe1/I6dvO8RgDg7OZzLRdq6hLZ2+PtkhKuR4WIUF1ayv2vnbqrVqkel5XKJ/KG1WcmCTFmFd1LH34IeUkJAKD07l1U5OcDAEoyM1FVWAgAKL59G9V//gkAKEpLg1wToMJr16AoLwcAFPz+O1SaxOZRcjLUCgVIrcajlBSoFQqo5XI8Sk4GAKiqqlDw++8AAEV5OQqvXQMAyEtLUZSWBgCoLi5G8e3bAICqwkKUZGYCACry81F69y4AoDw3F2XZ2QAA2cOHkD18CAAoy85GeW5uTfnuXVTWZ1NxcYM2/XntGrT5tp5Nyck1J5BC0aBNpFJBXlZmsk3lDx+i3IBNDcZJa9Pt29zJY1ScdG1KSQGpVFBWVvKOU2lWVk25oIBXnPRsunMHlTzipGtTQWoq1HI5rzjp2kQqlUltr/zhQ5BKBdn9+/zipGNTKwAKzbgso+KksUlZWcnZYer5RCoVKqRSfnHKzERlYSFIpeIdJ84mlQoFqakglYpXnLQ2aVe5NuUaUSGVglQq3nEqvHYNiooKTndj46RnU0UF/tTYwfe6VyGVQnb/Pq84GbKp+PZtftfy5GSQSgVVdTUepaTwipPWpsrCQpTcucMrTro2mXotlz14gNI7dyAvLcWXLVuyVXSbm4ZW0S0rKqLr169TZWUlqZRKUqtURER6ZWV1NeVevlyzUqlSSWq1+vE+DZTVavVjWYWCm5+tVqsbL6tUXH25ly9zKyZqt2vLWh0NlTlZzQqL9dlXnx2K6mq6fvkyKXXs1uqoWzZkh0G7a+leX9mQ7rr2NWiHjqz29cTGxMnkmNXSXeszhVxudJwM6V5vzBqwQ9duY+NkKGZKI2Oma4dSLuf0NjZOurorlcqattZAzOqzSaVQcOensXHSLRvSvbE4acucbHW10XHSi5lWd52YNRYnbVmpUHDnp7FxMitmOrpr9dau2GxMnIyKmRHXCK3eWv2MiZNezDR+UxjQvbG2p2u3sXFqSHc+1whdWT7X8srKSrp+7RoV5ebSFoBK79+3+Cq6z2wSYuhlZZWVlXTjxg2q1CQljMdwN4ZGXm6zc+dOkkgkzaOUBfDz86N//etfRu1rrM90iYqKotDQUNOUewIAoOjo6Cdej65fTfEbEVFYWBgtWrSo6ZWrxdPYxk312bPOk/Rbc507fGiKe1xTJyHPzOOYpoKIoKys1H923QyyTVV3+/bt8euvv/KSXbt2LWbMmGHUvlOmTMFtTXejlj179iAkJISbHvbGG2+gUNN9yEf35vT5rl270LJlS7Njxpdly5YhNjYWgPG6f//993j++ecBAP7+/tiyZUuTtbWcnByMGjXKJNmm8Bmf9vrTTz9h3bp1XN0ymQzz58+Hj48PHBwc0LVrV+zYsUNPZsiQIRAIBHqfuW+++dSc3+vXr0ffvn3h7OwMDw8PjB8/Hrdu3dKTq6qqwoIFCzAoPBwSiQSTJk1CXl5ek+n+1ltvoWPHjnBwcEDr1q0xbtw43Lx50yhZc+vWtufanDx5EgMGDICzszNat26NSZMm4a7mcUZzodU7KioKPXr0MFle1+767DVGlg9qlQqF168/HltjQVgSwhNSq/FnWpreAKHmkG2Kus8fO4aioiKEhYXxkj169CjGjh1r1L4ODg7w8PDg/r9w4QJmzpyJKSNG4I/UVBw6dAiXLl3CnDlzeOlujT43BScnJ7i5ufGq++jRo3j55Zf1tjUkq1KpoG7kmFr5Nh4esLOz42VDU/ksNTWVV3t1dXWFk6MjV/eSJUtw4sQJ7NmzB2lpaXjnnXcwf/58HDt2TE9uzpw5kEqlkEqlePjgAVbMmPHUtLWzZ88iMjISFy9exKlTp6BQKDB8+HCUa57vA8DixYsRExODz9avx+nTp5GTk4OJEyc2me69e/fGzp07kZaWhpMnT4KIMHz4cO5ljs19jmVlZWHcuHF46aWXcDUpCT9u2YKCR49422wuWr1havL1BK9rcrm8QXllZSUODhzIjROxKE3Sn2JF8H0co1arqbxaYZGP9nleU7Fu3TqaMmUKL5ns7GwSi8X0559/0vXLl2nTpk3UrVs3atGiBfn4+NC8efOorKyM2792V/WmTZuoQ4cOesf84osvqG3btkRU4/OuXbvSnDlzuO8zMjLIycmJvv3223r1SklJoSFDhpCTkxM5OztTr1696PLlyySTycjZ2ZkOHTqkt390dDS1aNGCSktLKSsriwDQ4cOHaciQIeTg4EAhISEUHx9PRERnzpwhAHqfqKgoIqp5bPDRRx/R66+/Tk5OTuTr60tffvllHZ9NnjyZJBIJubi40NixYykrK4v7/syZM9S3b19q0aIFSSQSGjRoEN29e5eI6j6OaWhfrf8cHR0pLS2NwsLC6uitG5OjR49SUFAQiUQiysrKokuXLlF4eDi5ubmRi4sLDR48mJKSkvRsgU6XcmN+03L+/Hl6/vnnyd7ennx8fGjBggUkk8m47/Py8uh//ud/yN7envz9/WnPnj0GH8esWbOGa68FBQX06quvkre3Nzk4OFC3bt1o3759evXWfhwTHBxM69at09unV69e9M9//rNeGWOo3cbz8/Opd+/eNH78eKqqqqLevXvTpk2buO/HjRtHNjY23HlyX9Odna4Zl7Z9+3bq1KkT2dnZkYeHB02aNKneuvPz8wkAnT17loiIiouLydbWlg4cOMA9VkhLSyMAlJCQ0KAdKpWK2rZtS//7v/+rt/3q1askEAj02pkuv//+OwGgjIyMBo+/c+dO8vX1JQcHBxo/fjxt3rxZz28ZGRn08ssvk4eHBzk6OlKfPn3o1KlT3Pf1tedDhw6RjY0NqTRjH4iIjh07RgKBgOSa8VOGUCqVtHjxYpJIJOTq6krLly+n1157jV4KC6v3cYw21tHR0VyMhg8fTtnZ2dz3tXXcuXMnEdWcO19//TWNHz+eHBwcqFOnTnT06NF69avPXmPbfmRkJC1atIjc3NxoyJAhBut4Gh/HsCREB0MBKq9WkN+KGIt8yqsVevqp1WqqLiszKTlRq9XUu1cv2rt3Ly+5bdu20fDhw7kbw6effkqnT5+mrKwsio2NpYCAAJo3bx63f+0L9G+//Ua2trZ05N//JpVKRbm5uTR48GC9pCM5OZnEYjEdOXKElEolDRgwgCZMmNCg3cHBwTR9+nRKS0uj27dv08GDByklJYWIiObMmUOjR4/Wk3355ZdpxowZRPT4ZhoYGEgxMTF069Yt+tvf/kZ+fn6kUCiourqatmzZQi4uLpSTk0P3MjKotLSUiGqSEFdXV9q+fTulp6fT+vXrSSgU0s2bN4mISC6XU1BQEL3xxhuUnJxMxw4epKlTp1JAQABVV1eTQqEgiURCy5Yto4yMDLpx4wbt2rWL7t27R0T6SYhcLieJREJLly41uC8RUUxMDHXp0oWIiAoLC8nHx4fWrVvH6a1Wq2nnzp1ka2tLgwYNogsXLtDNmzepvLycYmNjaffu3ZSWlkY3btyg2bNnU5s2bai0tJTzm6EkpD6/EdXcWBwdHWnThg1069YtunDhAvXs2ZNmzZrF6Txq1CgKDQ2lhIQEunLlCg0aNIgcHBzqJCF9+vThLrYPHjygTZs2UXJyMmVmZtIXX3xBIpGIEhMTueOGhYXRwoULubYyZ84c6tOnDz148IDUajWdPn2anJycuBu4Vsbd3Z3c3NwoODiYVqxYQUV5eQ2eY7ptPDs7mwICAmjmzJk1baesjBYvXkxjxozh2p+rqyu5u7vT8ePHiYhoz549XBJ++fJlEolEtG/fPsrKyqLE336jLVu21Ft3eno6AaA//viDiIhiY2MJABUUFOiNbWjXrh199tln9R5Hy7Jly+j555/XO8eWLl1Kzz//vMH9ZTIZvfPOO9S+fXuq1hmQWfv8vHjxIgmFQvrkk0/o1q1b9Pnnn1PLli31rg0pKSm0Y8cOSk1NpWvJyfTPf/6T7O3tufat256lUilJpVIiIrpz5w6JxWL65ptvSKFQUP6DBzR58mQaNmxYg7Z+8skn1KpVKzp8+DDX3p2dnRtNQmxtbalPnz4UHx9PV65coX79+tGgQYNIrVZTcX4+LVmyhIKDgzkdKyoqiKgmCfHx8aF9+/ZReno6LVy4kJycnKiwsNCg3+qzt762/9uZM5xsWFgYOTk50fLly+nmzZvc9ag22ntceVkZ5cTHcwP2+cCSEDOx5iREpVRSfkqKSSsfZt+7R2JbWyosKOAlN2zYMNq2bVu9A7gOHTpEbm5u3P+GBu3t37+fHFu0IBsbGwJAY8eOrfOLZePGjeTu7k7z588nLy8vKtDR05Ddzs7OtGvXLoM6JyYmkkgkopycHFIplXT99GmysbGhuLg4Inp8M/3mm284mevXrxMASktL07Ojdt1+fn40ffp0Tk6tVpOHhwf93//9HxER7d69mwICAvRmeVRUVJCDgwOdPHmSCgsLCQCnS210k5BHml+9p2NjDe5LVJNwLVu2jPtf26Ogq7f215o2SasPlUpFzs7O9PPPP3PyhpKQhvw2e/ZsmjNnjp7Pzp8/T0KhkCorK+nWrVsEgC5dusQdQ/vLXTcJOf3LLyQWi6moqKhefceMGUNLly7l/tcmIdq6q6qqaMaMGQSAbGxsSCwW0/fff693jC+//JJOnDhBqampXHIw+qWXGjzHtG3j5s2b5OvrSwsXLuRmQOSnpNCR6GiSSCSkVCopJSWFPD09adGiRbRixQoiInrzzTdp2rRpRER0+PBhcnFxodLS0kbPb5VKRWPGjKHnnnuO27Z3714Si8V1zs++ffvSP/7xj3pt0JKcnEwCgYCy7tyh/JQUUsjl1LZtW649a9m+fTs5OjoSAAoICNDrBTGk99SpU7kfAlqmTJlicECvrnxwcDBt3bqV+66+geBxcXHk4eFBIpGIANDAAQMabCtERF5eXrRx40buf4VCQT4+Po0mIQDo4sWL3Daupyk+nvJTUmj1++8bHEwOgFatWsX9L5PJCACXjBrym7ED30ePHk3zZszgZMPCwqhnz56NymnvcSUFBfRN27ZUrflxxYemTkLYG1MbwcFWhBvrRlisbl2EIhFa67ysjA8xv/yC5194Aa6a8QbGUFpairNnz+Lbb7/ltv3666/YuHEjbt68idLSUiiVSlRVVaGiosLgW2Zv3LiBxYsXI2rNGowYMQJSqRTLly/H22+/rXfcpUuX4siRI9i2bRuOHz/OjYsAABeJhCtPnz4dO3bswJIlS/Dmm29i9+7dCA8Px+TJk9GxY0cAQL9+/RAcHIzvv/8e7777Lk4kJ8PPzw+DBw/W0y0kJIQre3l5AQDy8/MRGBjIbTfkc105gUAAT09P5Gvm7P/+++/IyMiAs7MzgJqlAIRCIaqqqpCZmYnhw4dj1qxZGDFiBIYNG4bw8HC88sorXP26uLdujVmzZmHU6NEG9yUi/Pzzzzh48GAd2dp6i8ViPb0BIC8vD6tWrUJcXBzy8/OhUqlQUVGB7OzsBttaQ377/fffkZqain379nH7EBG3JMLt27dhY2OD3r17c98HBgaiZcuWenWcOXcOzz33HLddpVLh448/xsGDB/Hw4UPI5XJUV1fXaXMCgYDTe+u//oWLFy/i2LFj8PPzw7lz5xAZGQlvb2+Eh4cDAObOncvJdu/eHV5eXhg6dCiy7t5Fx44dERwcjHv37gEAXnjhBRw/fhwAUFlZiRdeeAHTpk3jBhIKND4L8/NDWVkZkpOTER8fj7CwMAwZMgQbNmwAUDPOY/ny5QCAYcOGwc/PDx06dMDIkSMxcuRITOjc2eC5FBkZiWvXruG3334zGBdT6NGjB4KCgrD/wAG8++67OHPmDPLz8zF58mS9/SIiIjBs2DBIpVJs3rwZr7zyCi5cuAB7e3t0Dwmp46O0tDRMmDBB7xgDBw7EiRMnuP9lMhnWrFmDX375BVKpFEqlEpWVlcjWvCOjPnJzczFnzhzMnDkTU6dORVlZGVavXo2//e1vOHXqFO7fv4+uXbty+7/33nuIjIyEVCpF//79ue3adlimea9GfdjY2HDvlwIet9dbt29jwMyZEERH1yure644OjrCxcWFu1YYez2vr+1PmDBB722puudUY4gdHTH7wQOj93+SsCSkEQQCAVqIH7uJiCAvLYXYxcWk9/2bKmuu/LFjxzB62LCaNzMaKXv8+HF07doVvr6+UKlUeJiTg3GvvIJ58+bho48+gqurK3777TfMnj0bcrnc4IVz/fr1eO6557Bw7lyIXVwQEhICR0dHvPDCC/jwww/1bmK3b9+GSCRCeno6Ro4cyR0jOTkZCpkMtk5OkGgSkjVr1mDatGn45ZdfcPz4cURFRWH//v3che/NN9/E9u3bsWLFCnz37beYNWtWHbttbW25MvdW0loDvQz5XFdOK6uVk8lk6N27N/bu3QuVSoU7N26gQ9euEIlEaN26NQBg586dWLhwIU6cOIEDBw5g1apVOHXqFAYMGFCn7h1btmDBggU4efJknX0vXboEpVKJQYMG1fG7rt5AzYDh2vbPnDkThYWF+Pzzz+Hn5wc7OzsMHDgQcrmckzdEQ36TyWSYO3cu5r3xBmydnPTqbNeuXZ2ZU/Vx5tw5TNS5EW7atAmff/45tmzZgu7du8PR0RHvvPNOnQF4RITqkhKobG3x3nvvITo6GmPGjAFQc0NISUnB5s2buSSkNv369QMApKeno2PHjvjPf/4DhUIBoMaHWuzs7BAeHo6YmBgsX74cbdu25XwmkUgQGhqKuLg4JCQkYNiwYRg8eDA3cyw9PZ0bbOvs7IyrV68iLi4OJ0+exPurVmHNmjW4fPmyXmI2f/58xMTE4Ny5c/DRWXjT09MTcrkcxbVupHl5efD09DTK1xEREdi3bx8Wz5uHvXv3YuTIkXo/AgBAIpFAIpGgc+fOGDBgAFq1aoXo6GhMnToVv/zyCyqKimDr5FTvcheGWLZsGU6dOoVNmzbBz9MTLq1bY/LkyY0Oqty+fTskEgk2btzI+Xz37t1o164dEhMT0adPH6RoXiAG1AxYfhJo2xo1MDC1oWuFsdfz+tp+VXm53vXc0dHRaN3VSiXunTwJ36FDIbSxbBrAZsfwhNRqyO7fN3lEs6my5sjLZDKcOXMGL/XsyUv26NGjGDduHPf/9Zs3oVar8emnn2LAgAHo0qULcnJyGjxGRUUFBAKBnt7aNRp0T9433ngD3bt3x/fff48VK1YgTfOGQQDo2KED2tjaomOHDnozb7p06YLFixfjv//9LyZOnIidO3dy302fPh337t3DF59/jrSbNzHjtdeMthuo6TlQaV6BzMfnvXr1Qnp6Ojw8PNCpUyf4+fqiU6dO6NSpE5dAAUDPnj2xcuVKxMfHo1u3bno9B1q0dfcIDTW479GjRzFmzBi9NS/46H3hwgUsXLgQo0ePRnBwMOzs7FBQUKBXN1969eqFtBs3uHhpbe/UqRPEYjECAwOhVCqRlJTEydy6dUvvJiqTyXApKUlvxs+FCxcwbtw4TJ8+HaGhoejQoUO9CY3s/n3Iq6uhUCjqrIwqEokanBmUfPUqAMCzTRsAgJ+fH6d/27Ztuf2EQiF2796N3r1748UXX0ROTo6ez8PCwnDmzBmcO3cOQ4YMgaurK4KCgvDRRx/By8sLXbp04Y5lY2OD8PBwfLJhA+IOHMDdu3dx+vRpADXnyPz58xEdHY3Tp0+jffv2evr27t0btra23P5af2ZnZ2PgwIH12qnLtGnTanpYTpzA4cOHERER0eD+pHl1eXV1NQCgna8vF2+tj4KCgpCYmKgnd/HiRb3/L1y4gFmzZmH8uHHwd3FBGw+POtNste1Zl4qKCi6uWp8LdZJhGxsbvXbn6uoKiUQCLy8vPZ2USiWuauLdEEqlEleuXOH+17bXwIAAyO7fh9jWto6OxmDoHDVkb31tX1lZafK9RFldjXNLlnBLllgSloTwRCgSwa1bN5MWLDJHtjH5bdu2YejQoQCAhw8fIjAwEJcuXQIAnDhxAl26dEHPESM42dr7AMCMGTOwcuVKADUn3vHjx/VuBO18fKBQKLB161bcuXMHu3fvrvPehdqMHTsW0dHROHj+PO7eu8fd+Pr16wdvb28ANb9sEhIS8P333yMiIgLjx49HREQE94uott2VlZWYP38+4uLicE9zzMuXLyNI55XCrVq1wsSJE/GPFSswfPhwtPPz4+Vrf3//muQtLg7k6YkqzQW3MSIiIuDu7o5x48bh/PnzePDwIeLi4rBw4UI8ePAAWVlZWLlyJRISEnDv3j3897//RXp6up7uWu5lZ2Pz3r1IvHTJ4L7Hjh2rMzXX398f586dgzQ3F+Tp2WBb69y5M3bv3o20tDQkJiYiIiKC+7Wv9TlfVqxYgfiEBETt2IHUP/5Aeno6jh49ivnz5wMAAgICMHLkSLz11ltITExEUlIS3nzzTb1ehpMnT8K/XTv4+/vr6Xrq1CnEx8cjLS0Nb731lsF3YQgEArh164aWrVohLCwMy5cvR1xcHLKysrBr1y788MMPXG9ZZmYmPvjgAyQlJeHu3bs4duwYZr3+OgYPHowemnVUGkIkEmHv3r0IDQ3FSy+9hPxHj7h2OmTIEJw8eRI2Njbc470hQ4Zg7969elOOY2Ji8MUXXyAlJQX3HzzAL0lJUKvVCAgIAFDzCGbPnj3Yt28fnJ2dkZubi9zcXFRWVgKo6aGYPXs2li1bhsQrV5CUlITXX38dAwcOrNOzVh/+/v4YNGgQlq5fD5VKpdem7ty5g/Xr1yMpKQnZ2dmIj4/H5MmT4eDggNGjRwMwfF3S9vRt3rwZ6enp2LZtm96jGG1Mf/rpJ6T+8QceqFSY/tprdRJEbXt++PAhlyCPGTMGly9fxrp165B55w7uyeWY/eab8PPzQ88G4rZo0SJs2LABR44cwc2bN/H3v/+9Tg+S7nVUi62tLRYsWMC111mzZmHAgAEYMHAg3Lp1Q/sOHZCVlYWUlBQUFBRwyVljCEUiPPe3v+GozpRxQ/bW1/bFLi4m30vEjo547fp1iJ2cTJJvUppkZIkVYe4bU9UqFVUWFnKvxuWDObKNyUdFRZGfnx8RPR5AeObMGSIimj59Or333nt6srX3IaoZ3DRz5kwiIvr111/Jx8eH+0478G3z5s3k5eVFDg4ONGLECPrhhx8IADcozNDA1M8//5yCAgLIwcGBvLy8KCIigh48eEBENYO8HBwc9KacFRUVka+vLzewrrbd1dXV9Oqrr5Kvry+JxWLy9vam+fPn14mbdubAnu++0/OZ1vbk5GS9Omv74+233yY3NzcCQKtXryYiwwPHQkNDuSm8RERSqZRmzJhB7u7uJBaLqUOHDjRnzhwqKSmh3NxcGj9+PHl5eZFYLCY/Pz9avXo1N91Qd2CqNCeHxo4ebXDfjIwMsrOz05v6SkSUkJBAISEhZGdnRwBIrVLV+4bPq1evUp8+fcje3p46d+5Mhw4d4uzT+hwGBqY25rfEixdpqGb6tKOjI4WEhNBHH32k558xY8aQnZ0dtWvXjn744Qc9v0ZERNDcN97QGyxYWFhI48aNIycnJ/Lw8KBVq1bRjBkzaNy4cdw+2oGp2rYilUpp1qxZ5O3tTfb29hQQEECffvopN6MgOzubBg8eTK6urmRnZ0edOnWiZcuWUV5WVoPnaG1/KhQKmjhxIgUFBdG9mzdJrVJRYWEhCQQCvSnx0dHRBIB27NjBbTt//jyFhYVRq1atyMHBgboHB9P+H3/kvketKZvaj3YaKFHNdWvevHnk4uJCLVq0oAkTJnAzK4xl+7ZtBIBmvPaa3vaHDx/SqFGjyMPDg2xtbcnHx4emTZumN/uivuvSt99+Sz4+PuTg4EBjx46tM0U3KyuLXnzxRXJwcCCftm1p69atdaZM127PWn788Ufq2bMnOTo6Umt3d3p57FhucHR9KBQKWrRoEbm4uFDLli1pyZIldabo6l5HiR7H+vDhw9ShQweys7Oj8PBwunfvHmd3ZUUFTZo0iVq2bFlnim7tN6ZKJBLue7VKRQDoO51XERiy12Dbf+01+p9RozifGzvVXHuPk5WW0u2DB7klIfjAZseYidlrx8jlVHjjxuN39vNcO0ZXloj/2jGFN27oraHS2HoD8upqcnV1pYT4+Jq6ddfjaGC9gQULFtDbb7/N2WHW2jFan5mxdoyu7sauC/H9rl3k5uZGOSkpZq0dY3TMnsDaMQX1xGzzpk00atSoeu1QKZVUcP263v+81o7hGTNdO1QKRY2sCWvHyOVycnV1pR937TJt7RgDdjcWJ92yrt18147R2l1n/RVj144xRvcntHZMvbobuXZM4Y0bja4d891333FJSO21Ywo05xjftWO4tqY0be2YGZokpL61Y7799ltO59o2cddjE9eO0bPbhLVj9O5DPNeOKXn0iPYPGECynByLrx3zzDyOaapVdEsyMtCiTRsIRSLeq+gWpKaiZZcuIJXKpFV0hSIRHNzdudVZjVl5MTs1FZGzZ6P/gAEQisWo1HTxNbbyYrdu3fDq0KFNsorunzduwDUoCIrycpNW0RWKRLB1ckK5VAqg8RUyKyoqkPzrr9iwfj3eeustiEUizg6+q+gWpKbCNSgIarm82VfRFYpEEIpEqC4qqhOnlgCWLlhQr01CkQhKzeqmxsZJ16biW7fgGhRUU+a7iq5UCtegoJoyz1V0c+/dw6JFizC4a1eTVtFVy+Wc/aasoluWnQ3XoCCubEyctDZVFxXBNSgIJRkZJq2iCwBKjc3Nvopufj5cg4K4cmNx0rVJWVUF16AgFF671mCcSKUCacY76NqkrKqCWi6HUCTiv4pufj5sHBwgFIlMWkVXpXnkW98qujKdmTq1bQIASceOKEhN5RUnrU3VRUXcOc57RfTsbNi1agWhSGTSKrrlUimmJCTgG29vtopuc2NuT4hKoaDyvDwuc+W18qJcTuX5+fpZL4/sWa1SUXlenl6PgLHZMyer84vR2OyZyLyeEJVCQRX5+fq9CTx6Qmrr3tivnKioKLKxsaGXXnqJSktK6trNoydEJZfX6G5MzJq4J6TRmDVkh0pF5bm53K8cvj0hfGOm96taqayR1elNMLYnRPf9Kib1hBiwu7E46ZV17ObdE1Kf3cZeI4zRnWdPyNy5c8nR0dHgZ+7cuabHTLcnRCsrl5vWE6JUctdU3j0hurLN3BOiVqmoXGO3sXFqSHde14ja9yGePSGlRUX0x9dfU8WjR6wnxFLY2Ntzf3XL2ulOQpEIAs0IbN0yBAJUFxeDiGq26+7fQFkgEABCIaqLijjZmsMJGi8LhRCKRDUj0ouLAc2xtdu1Za2OhsqcrIb67KvPDoHOAChdm2qXDdkBgQBVml/ztW1qrGxId137DNmxZs0aKBQKxMbGwtHRsa7djcSpdsyqiooAY2JWW/cGbGqorLWj0Zg1YAfpTB80Nk7mxEzXDgA1sgJBg3FqyCaNIkbHiRugZ8DuxuKkW9a129g46frIoN1GXiMMxayxOHF26/hN16YPPvgAKSkpBj8ffPCB6THT0Z2TFQobjNPrr7/ODQTV0x3grqnGxsmgrJFx0i1/t3Mntm7eDEE9sXnjjTc4nWvbREQ1vZTaOnlcyw3pzucaUec+xOdaLhQCajXSDx2CjYNDzXEFAthppgoLhELYaab2C0Wix2UbG4g17z9qSgREzbQ86FNCqWYe/8P79+GtM98eqFmNMisrC+3bt4e9JjFh1KBSqXArORkBPXvqTQll1A/zmWkwv/GH+cw0njW/NcU9LufBA7T19UVJSQlcNAmKOTyzPSEN0VBeRmo1ynNzTX5PiKmylq7bHKzZbmv1mzX73Bys2W5r9Zs1+9wcrNFu7b1NJZfj6mefQWnkdOInCUtCdNC+3a5CMzjMEEQEheZNdXwxR9bSdZuDNdttrX6zZp+bgzXbba1+s2afm4M12q29t4kEAkgTEriBwpaEPY6phVQqRXFxMTw8PNCiRQuTXq/+V0SlUiErLQ3tg4KeiW7LpoD5zDSY3/jDfGYaz4rfiAgVFRXIz89Hy5YtDa5VZSxN/TiGrR1TC+16C9pFhmpDRJCXlEAskZi2doyJspauW61WI7+gAIK7d+u8CvtJ122tPjfHZ+bWbc0+Z22NtbXmqvtZa2stW7aEp6cnlNXVuLJ+PfqsXAkbOzu+qjcpLAmphUAggJeXFzw8PLiFq3RRVlXh0nffod+qVdysGmMxR9bSdZfLZFg2Zgz2XLkCR56v+rVmu82RN8dn5tZtzT5nbY21teaq+1lqa7a2to97e9RqyB48ACwwlqY27HEMwyhkpaV4QSLB+ZISODVBF9yzAPOZaTC/8Yf5zDSY3/jzl5wds337dvj7+8Pe3h79+/fXW1TNEIcOHUJgYCDs7e3RvXt3/Oc//2kmTWsyUFNXHzRH1tJ1m4M1222tfrNmn5uDNdttrX6zZp+bgzXbbUm/1cbiSciBAwewZMkSREVF4erVqwgNDcWIESPqHZMRHx+PqVOnYvbs2UhOTsb48eMxfvx4XNO8IpfBYDAYDIZ1YPHHMf3790ffvn2xbds2ADUDhXx9fbFgwQK8++67dfafMmUKysvLERMTw20bMGAAevTo0eiy8gB7HGMqrNuSP8xnpsH8xh/mM9NgfuPPX2p2jFwuR1JSElauXMltEwqFCA8PR0JCgkGZhIQELFmyRG/biBEjcOTIEYP7V1dXo1rnhSwlmgXq8jSLofFFWVWFi6tWYcCHH5o0mMhUWUvXXVFWBhWA3IcP0UKzKFJz1W2tPjfHZ+bWbc0+Z22NtbXmqpu1Nf7y2ntnk/VfNLq6zBPk4cOHBIDi4+P1ti9fvpz69etnUMbW1pb27dunt2379u3k4eFhcP+oqCgCwD7swz7swz7swz5N9MnMzGySPOAvP0V35cqVej0nxcXF8PPzQ3Z2NiSa5Yr50rdvX1y+fLnZZS1Zd2lpKXx9fXH//n2TuuCs1W5z5M31mTl1mytrybpZW2NtrblkWVvjL19SUoJ27drB1dXV5Lp1sWgS4u7uDpFIhLy8PL3teXl53EvDauPp6clrfzs7O9gZeBmLRCIx+WQViUQWkbV03QDg4uJi0jGs2W5z5U31mbl1W7PPAdbWTIG1NdNgbY0/prwUz+BxmuQoJiIWi9G7d2/ExsZy29RqNWJjYzFw4ECDMgMHDtTbHwBOnTpV7/5PgsjISIvIWrpuc7Bmu63Vb9bsc3OwZrut1W/W7HNzsGa7Lek3XSw+O+bAgQOYOXMmvvzyS/Tr1w9btmzBwYMHcfPmTbRp0wYzZsxA27ZtsX79egA1U3TDwsKwYcMGjBkzBvv378fHH3+Mq1evolu3bo3Wp50d01Qje58VmN/4w3xmGsxv/GE+Mw3mN/40tc8sPiZkypQpePToEVavXo3c3Fz06NEDJ06cQJs2bQAA2dnZet0+gwYNwr59+7Bq1Sq899576Ny5M44cOWJUAgLUPJ6Jiooy+IiGUT/Mb/xhPjMN5jf+MJ+ZBvMbf5raZxbvCWEwGAwGg/FsYvE3pjIYDAaDwXg2YUkIg8FgMBgMi8CSEAaDwWAwGBaBJSEMBoPBYDAswjOfhPj7+0MgEOh9NmzYYGm1niq2b98Of39/2Nvbo3///rh06ZKlVXqqWbNmTZ02FRgYaGm1njrOnTuHsWPHwtvbGwKBoM76T0SE1atXw8vLCw4ODggPD0d6erpllH1KaMxns2bNqtP2Ro4caRllnxLWr1+Pvn37wtnZGR4eHhg/fjxu3bqlt09VVRUiIyPh5uYGJycnTJo0qc5LMZ81jPHbkCFD6rS3t99+m1c9z3wSAgDr1q2DVCrlPgsWLLC0Sk8NBw4cwJIlSxAVFYWrV68iNDQUI0aMQH5+vqVVe6oJDg7Wa1O//fabpVV66igvL0doaCi2b99u8PuNGzfiiy++wI4dO5CYmAhHR0eMGDECVVVVzazp00NjPgOAkSNH6rW9H3/8sRk1fPo4e/YsIiMjcfHiRZw6dQoKhQLDhw9HeXk5t8/ixYvx888/49ChQzh79ixycnIwceJEC2pteYzxGwDMmTNHr71t3LiRX0VNsgKNFePn50f/+te/LK3GU0u/fv0oMjKS+1+lUpG3tzetX7/eglo93URFRVFoaKil1bAqAFB0dDT3v1qtJk9PT9q0aRO3rbi4mOzs7OjHH3+0gIZPH7V9RkQ0c+ZMGjdunEX0sRby8/MJAJ09e5aIatqVra0tHTp0iNsnLS2NAFBCQoKl1HzqqO03IqKwsDBatGiRWcdlPSEANmzYADc3N/Ts2RObNm2CUqm0tEpPBXK5HElJSQgPD+e2CYVChIeHIyEhwYKaPf2kp6fD29sbHTp0QEREBLKzsy2tklWRlZWF3NxcvbYnkUjQv39/1vYaIS4uDh4eHggICMC8efNQWFhoaZWeKkpKSgCAW4AtKSkJCoVCr60FBgaiXbt2rK3pUNtvWvbu3Qt3d3d069YNK1euREVFBa/jWvyNqZZm4cKF6NWrF1xdXREfH4+VK1dCKpXis88+s7RqFqegoAAqlYp7e62WNm3a4ObNmxbS6umnf//+2LVrFwICAiCVSrF27Vq88MILuHbtGpydnS2tnlWQm5sLAAbbnvY7Rl1GjhyJiRMnon379sjMzMR7772HUaNGISEhASKRyNLqWRy1Wo133nkHzz33HPeW7dzcXIjFYrRs2VJvX9bWHmPIbwAwbdo0+Pn5wdvbG6mpqVixYgVu3bqFn376yehj/yWTkHfffReffPJJg/ukpaUhMDAQS5Ys4baFhIRALBbjrbfewvr169mrfBkmMWrUKK4cEhKC/v37w8/PDwcPHsTs2bMtqBnjr86rr77Klbt3746QkBB07NgRcXFxGDp0qAU1ezqIjIzEtWvX2BgtntTnt7lz53Ll7t27w8vLC0OHDkVmZiY6duxo1LH/kknI0qVLMWvWrAb36dChg8Ht/fv3h1KpxN27dxEQEPAEtLMe3N3dIRKJ6owSz8vLg6enp4W0sj5atmyJLl26ICMjw9KqWA3a9pWXlwcvLy9ue15eHnr06GEhrayPDh06wN3dHRkZGc98EjJ//nzExMTg3Llz8PHx4bZ7enpCLpejuLhYrzeEXedqqM9vhujfvz8AICMjw+gk5C85JqR169YIDAxs8CMWiw3KpqSkQCgUwsPDo5m1fvoQi8Xo3bs3YmNjuW1qtRqxsbEYOHCgBTWzLmQyGTIzM/VupoyGad++PTw9PfXaXmlpKRITE1nb48GDBw9QWFj4TLc9IsL8+fMRHR2N06dPo3379nrf9+7dG7a2tnpt7datW8jOzn6m21pjfjNESkoKAPBqb3/JnhBjSUhIQGJiIl588UU4OzsjISEBixcvxvTp09GqVStLq/dUsGTJEsycORN9+vRBv379sGXLFpSXl+P111+3tGpPLcuWLcPYsWPh5+eHnJwcREVFQSQSYerUqZZW7alCJpPp9Q5lZWUhJSUFrq6uaNeuHd555x18+OGH6Ny5M9q3b4/3338f3t7eGD9+vOWUtjAN+czV1RVr167FpEmT4OnpiczMTPzjH/9Ap06dMGLECAtqbVkiIyOxb98+HD16FM7Oztw4D4lEAgcHB0gkEsyePRtLliyBq6srXFxcsGDBAgwcOBADBgywsPaWozG/ZWZmYt++fRg9ejTc3NyQmpqKxYsXY/DgwQgJCTG+IrPm1lg5SUlJ1L9/f5JIJGRvb09BQUH08ccfU1VVlaVVe6rYunUrtWvXjsRiMfXr148uXrxoaZWeaqZMmUJeXl4kFoupbdu2NGXKFMrIyLC0Wk8dZ86cIQB1PjNnziSimmm677//PrVp04bs7Oxo6NChdOvWLcsqbWEa8llFRQUNHz6cWrduTba2tuTn50dz5syh3NxcS6ttUQz5CwDt3LmT26eyspL+/ve/U6tWrahFixY0YcIEkkqlllP6KaAxv2VnZ9PgwYPJ1dWV7OzsqFOnTrR8+XIqKSnhVY9AUxmDwWAwGAxGs/KXHBPCYDAYDAbj6YclIQwGg8FgMCwCS0IYDAaDwWBYBJaEMBgMBoPBsAgsCWEwGAwGg2ERWBLCYDAYDAbDIrAkhMFgMBgMhkVgSQiDwWAwGAyLwJIQBoPBYDAYFoElIQwGg8FgMCwCS0IYDIbVIpfLLa0Cg8EwA5aEMBiMZuXf//43unfvDgcHB7i5uSE8PBzl5eWYNWsWxo8fj82bN8PLywtubm6IjIyEQqHgZP39/fHBBx9gxowZcHFxwdy5cy1oCYPBMBcbSyvAYDCeHaRSKaZOnYqNGzdiwoQJKCsrw/nz56FdR/PMmTPw8vLCmTNnkJGRgSlTpqBHjx6YM2cOd4zNmzdj9erViIqKspQZDAajiWCr6DIYjGbj6tWr6N27N+7evQs/Pz+972bNmoW4uDhkZmZCJBIBAF555RUIhULs378fQE1PSM+ePREdHd3sujMYjKaHPY5hMBjNRmhoKIYOHYru3btj8uTJ+Prrr1FUVMR9HxwczCUgAODl5YX8/Hy9Y/Tp06fZ9GUwGE8WloQwGIxmQyQS4dSpUzh+/Di6du2KrVu3IiAgAFlZWQAAW1tbvf0FAgHUarXeNkdHx2bTl8FgPFlYEsJgMJoVgUCA5557DmvXrkVycjLEYjF7vMJgPKOwgakMBqPZSExMRGxsLIYPHw4PDw8kJibi0aNHCAoKQmpqqqXVYzAYzQzrCWEwGM2Gi4sLzp07h9GjR6NLly5YtWoVPv30U4waNcrSqjEYDAvAZscwGAwGg8GwCKwnhMFgMBgMhkVgSQiDwWAwGAyLwJIQBoPBYDAYFoElIQwGg8FgMCwCS0IYDAaDwWBYBJaEMBgMBoPBsAgsCWEwGAwGg2ERWBLCYDAYDAbDIrAkhMFgMBgMhkVgSQiDwWAwGAyLwJIQBoPBYDAYFuH/AVACKDXco2rWAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 600x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Run the test. The folder with mixed audio and backgroundnoise files is specified (output folder in step 1)\n",
    "audio_snr_folder = os.path.join('kws_audio', 'Mixed_AN_All_TradeShow')\n",
    "\n",
    "# Reload a new checkpoint and model only if you want to test a different one\n",
    "'''\n",
    "trained_checkpoint_path = \"ai85-kws20_v3-qat8-q.pth.tar\"\n",
    "checkpoint = torch.load(trained_checkpoint_path)\n",
    "mod = importlib.import_module(\"ai85net-kws20-v3\")\n",
    "model = mod.AI85KWS20Netv3(num_classes=21, num_channels=128, dimensions=(128, 1), bias=False, quantize_activation=True,\n",
    "                           weight_bits=8, bias_bits=8)\n",
    "model.load_state_dict(checkpoint['state_dict'], strict=False)\n",
    "ai8x.update_model(model)\n",
    "'''\n",
    "\n",
    "# Run the accuracy test on the audio files for the range of SNR values\n",
    "x,y = run_accuracy_test(index_AN_ALL, class_AN_ALL, audio_snr_folder, snr_low=-15, snr_high=25)\n",
    "\n",
    "clear_output(wait=True)\n",
    "\n",
    "# Plot the accuracy of detecting the expected keywords in the audio files and the average confidence for all detections.\n",
    "# This does not check for false detections.\n",
    "f = plt.figure()\n",
    "f.set_figwidth(6)\n",
    "f.set_figheight(4)\n",
    "plt.plot(x, y, label = trained_checkpoint_path)\n",
    "plt.xlim((-5, 25))\n",
    "plt.ylim((0, 1.1))\n",
    "plt.xlabel('snr')\n",
    "plt.ylabel('avg accuracy')\n",
    "plt.title(audio_snr_folder)\n",
    "plt.legend()\n",
    "plt.grid(visible=True, which='major', color='#300000', linestyle='-')\n",
    "plt.minorticks_on()\n",
    "plt.grid(visible=True, which='minor', color='#900000', linestyle=':')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5493c89",
   "metadata": {},
   "source": [
    "# Step 5: Test the acceptance threshold for FAR=FRR\n",
    "In this test, we find the threshold of the confidence level to be used as the acceptance threshold such that False Acceptance Rate (FAR) equals the False Rejection Rate (FRR):\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "d71af1da",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "audio_snr_folder = os.path.join('kws_audio', 'Mixed_AN_All_TradeShow')\n",
    "\n",
    "# Reload a new checkpoint and model only if you want to test a different one\n",
    "'''\n",
    "trained_checkpoint_path = \"ai85-kws20_v3-qat8-q.pth.tar\"\n",
    "checkpoint = torch.load(trained_checkpoint_path)\n",
    "mod = importlib.import_module(\"ai85net-kws20-v3\")\n",
    "model = mod.AI85KWS20Netv3(num_classes=21, num_channels=128, dimensions=(128, 1), bias=False, quantize_activation=True,\n",
    "                    weight_bits=8, bias_bits=8)\n",
    "model.load_state_dict(checkpoint['state_dict'], strict=False)\n",
    "ai8x.update_model(model)\n",
    "'''\n",
    "\n",
    "f = plt.figure()\n",
    "f.set_figwidth(6)\n",
    "f.set_figheight(4)\n",
    "\n",
    "x, y1, y2, y3, y4 = run_far_frr_test(index_AN_ALL, class_AN_ALL, os.path.join(audio_snr_folder, ''), -5, 20, 10, 100, 5)\n",
    "clear_output(wait=True)\n",
    "plt.plot(x, y1, label='FAR')\n",
    "plt.plot(x, y2, label='FRR')\n",
    "# plt.plot(x, y3, label='TAR')\n",
    "# plt.plot(x, y4, label='TRR')\n",
    "plt.xlabel('Confidence Threshold')\n",
    "# plt.ylabel('Rate')\n",
    "plt.title(trained_checkpoint_path)\n",
    "plt.legend()\n",
    "plt.grid(visible=True, which='major', color='#300000', linestyle='-')\n",
    "plt.minorticks_on()\n",
    "plt.grid(visible=True, which='minor', color='#900000', linestyle=':')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "afa553b4",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.8.15 ('pytorch_18_maxim')",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.15"
  },
  "vscode": {
   "interpreter": {
    "hash": "474ed54277419883c73387ef2b46f4c12c6c08e2b4e83d016693fa3a47d64255"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
